icom-wlan-node 0.2.2 → 0.2.3

package/dist/index.d.ts

@@ -4,3 +4,4 @@ export { MODE_MAP, CONNECTOR_MODE_MAP, DEFAULT_CONTROLLER_ADDR, METER_THRESHOLDS
 export { parseTwoByteBcd, intToTwoByteBcd } from './utils/bcd';
 export { IcomRigCommands } from './rig/IcomRigCommands';
 export { AUDIO_RATE } from './rig/IcomAudio';
+export { setupGlobalErrorHandlers, setupBasicErrorProtection, GlobalErrorHandlerOptions } from './utils/errorHandling';

package/dist/index.js

@@ -14,7 +14,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AUDIO_RATE = exports.IcomRigCommands = exports.intToTwoByteBcd = exports.parseTwoByteBcd = exports.rawToCurrent = exports.rawToVoltage = exports.rawToPowerPercent = exports.getFilterString = exports.getConnectorModeString = exports.getModeString = exports.getConnectorModeCode = exports.getModeCode = exports.METER_CALIBRATION = exports.METER_THRESHOLDS = exports.DEFAULT_CONTROLLER_ADDR = exports.CONNECTOR_MODE_MAP = exports.MODE_MAP = exports.IcomControl = void 0;
+exports.setupBasicErrorProtection = exports.setupGlobalErrorHandlers = exports.AUDIO_RATE = exports.IcomRigCommands = exports.intToTwoByteBcd = exports.parseTwoByteBcd = exports.rawToCurrent = exports.rawToVoltage = exports.rawToPowerPercent = exports.getFilterString = exports.getConnectorModeString = exports.getModeString = exports.getConnectorModeCode = exports.getModeCode = exports.METER_CALIBRATION = exports.METER_THRESHOLDS = exports.DEFAULT_CONTROLLER_ADDR = exports.CONNECTOR_MODE_MAP = exports.MODE_MAP = exports.IcomControl = void 0;
 // Export types (includes ConnectionPhase, ConnectionMetrics, etc.)
 __exportStar(require("./types"), exports);
 // Export main class
@@ -44,3 +44,7 @@ var IcomRigCommands_1 = require("./rig/IcomRigCommands");
 Object.defineProperty(exports, "IcomRigCommands", { enumerable: true, get: function () { return IcomRigCommands_1.IcomRigCommands; } });
 var IcomAudio_1 = require("./rig/IcomAudio");
 Object.defineProperty(exports, "AUDIO_RATE", { enumerable: true, get: function () { return IcomAudio_1.AUDIO_RATE; } });
+// Export error handling utilities (optional, for robustness)
+var errorHandling_1 = require("./utils/errorHandling");
+Object.defineProperty(exports, "setupGlobalErrorHandlers", { enumerable: true, get: function () { return errorHandling_1.setupGlobalErrorHandlers; } });
+Object.defineProperty(exports, "setupBasicErrorProtection", { enumerable: true, get: function () { return errorHandling_1.setupBasicErrorProtection; } });

package/dist/rig/IcomControl.js

@@ -275,24 +275,48 @@ class IcomControl {
         const abortHandler = (reason) => {
             (0, debug_1.dbg)(`Aborting connection session ${sessionId}: ${reason}`);
             const error = new Error(reason);
-            rejectLogin(error);
-            rejectCiv(error);
-            rejectAudio(error);
+            // Defensive error handling: wrap reject calls in try-catch to prevent
+            // synchronous errors from propagating if promises are already settled
+            try {
+                rejectLogin(error);
+            }
+            catch (err) {
+                (0, debug_1.dbg)(`Warning: Failed to reject loginReady promise: ${err}`);
+            }
+            try {
+                rejectCiv(error);
+            }
+            catch (err) {
+                (0, debug_1.dbg)(`Warning: Failed to reject civReady promise: ${err}`);
+            }
+            try {
+                rejectAudio(error);
+            }
+            catch (err) {
+                (0, debug_1.dbg)(`Warning: Failed to reject audioReady promise: ${err}`);
+            }
         };
         this.abortHandlers.set(sessionId, abortHandler);
+        // Track promise states for defensive cleanup
+        let loginResolved = false;
+        let civResolved = false;
+        let audioResolved = false;
         // Temporary event listeners (local scope)
         const onLogin = (res) => {
             if (res.ok) {
-                (0, debug_1.dbg)('Login ready - resolving local loginReady promise');
+                (0, debug_1.dbg)(`Login ready - resolving local loginReady promise (sessionId=${sessionId})`);
+                loginResolved = true;
                 resolveLogin();
             }
         };
         const onCivReady = () => {
-            (0, debug_1.dbg)('CIV ready - resolving local civReady promise');
+            (0, debug_1.dbg)(`CIV ready - resolving local civReady promise (sessionId=${sessionId})`);
+            civResolved = true;
             resolveCiv();
         };
         const onAudioReady = () => {
-            (0, debug_1.dbg)('Audio ready - resolving local audioReady promise');
+            (0, debug_1.dbg)(`Audio ready - resolving local audioReady promise (sessionId=${sessionId})`);
+            audioResolved = true;
             resolveAudio();
         };
         this.ev.once('login', onLogin);
@@ -303,13 +327,36 @@ class IcomControl {
             civReady,
             audioReady,
             cleanup: () => {
+                // Defensive cleanup: wrap each cleanup step in try-catch
+                // to ensure all cleanup steps execute even if one fails
+                (0, debug_1.dbg)(`Cleaning up connection session ${sessionId} (login=${loginResolved}, civ=${civResolved}, audio=${audioResolved})`);
                 // Remove abort handler for this specific sessionId
-                // This is safe because the connection attempt is complete (success or failure)
-                this.abortHandlers.delete(sessionId);
-                // Remove event listeners
-                this.ev.off('login', onLogin);
-                this.ev.off('_civReady', onCivReady);
-                this.ev.off('_audioReady', onAudioReady);
+                try {
+                    this.abortHandlers.delete(sessionId);
+                }
+                catch (err) {
+                    (0, debug_1.dbg)(`Warning: Failed to delete abort handler: ${err}`);
+                }
+                // Remove event listeners - wrap each in try-catch
+                try {
+                    this.ev.off('login', onLogin);
+                }
+                catch (err) {
+                    (0, debug_1.dbg)(`Warning: Failed to remove login listener: ${err}`);
+                }
+                try {
+                    this.ev.off('_civReady', onCivReady);
+                }
+                catch (err) {
+                    (0, debug_1.dbg)(`Warning: Failed to remove civReady listener: ${err}`);
+                }
+                try {
+                    this.ev.off('_audioReady', onAudioReady);
+                }
+                catch (err) {
+                    (0, debug_1.dbg)(`Warning: Failed to remove audioReady listener: ${err}`);
+                }
+                (0, debug_1.dbg)(`Cleanup complete for session ${sessionId}`);
             }
         };
     }
@@ -376,11 +423,18 @@ class IcomControl {
             (0, debug_1.dbg)('disconnect() called but already IDLE - no-op');
             return;
         }
-        // Abort any ongoing connection attempts
+        // Abort any ongoing connection attempts - wrap in try-catch for defensive programming
         const currentSessionId = this.connectionSession.sessionId;
         if (currentPhase === types_1.ConnectionPhase.CONNECTING || currentPhase === types_1.ConnectionPhase.RECONNECTING) {
-            (0, debug_1.dbg)(`Aborting ongoing connection attempt (sessionId=${currentSessionId})`);
-            this.abortConnectionAttempt(currentSessionId, 'User disconnect()');
+            try {
+                (0, debug_1.dbg)(`Aborting ongoing connection attempt (sessionId=${currentSessionId})`);
+                this.abortConnectionAttempt(currentSessionId, 'User disconnect()');
+            }
+            catch (abortErr) {
+                // Log but continue - abort failure shouldn't prevent disconnect
+                const errMsg = abortErr instanceof Error ? abortErr.message : String(abortErr);
+                (0, debug_1.dbg)(`Warning: Failed to abort connection attempt: ${errMsg} - continuing with disconnect`);
+            }
         }
         // Transition to DISCONNECTING state
         this.transitionTo(types_1.ConnectionPhase.DISCONNECTING, 'User disconnect()');
@@ -1544,9 +1598,16 @@ class IcomControl {
                 (0, debug_1.dbg)(`Full reconnect attempt #${attempt} (delay: ${delay}ms)`);
                 await this.sleep(delay);
                 try {
-                    // Disconnect all sessions
+                    // Disconnect all sessions - wrap in try-catch to prevent disconnect errors from aborting reconnect
                     (0, debug_1.dbg)('Full reconnect: disconnecting all sessions');
-                    await this.disconnect();
+                    try {
+                        await this.disconnect();
+                    }
+                    catch (disconnectErr) {
+                        // Log but don't fail - we still want to attempt reconnect even if disconnect fails
+                        const errMsg = disconnectErr instanceof Error ? disconnectErr.message : String(disconnectErr);
+                        (0, debug_1.dbg)(`Warning: Disconnect failed during reconnect: ${errMsg} - continuing with reconnect anyway`);
+                    }
                     // Wait longer before reconnecting to allow rig to fully clean up old connection
                     // This is critical - rig may report CONNINFO busy=true if we reconnect too quickly
                     (0, debug_1.dbg)('Full reconnect: waiting 5s for rig to clean up old session...');

package/dist/utils/errorHandling.d.ts

@@ -0,0 +1,55 @@
+/**
+ * 全局错误处理工具函数
+ *
+ * 这个模块提供可选的全局错误处理器，帮助用户防止未捕获的 Promise rejection 和异常导致进程崩溃。
+ *
+ * 使用方式：
+ * ```typescript
+ * import { setupGlobalErrorHandlers } from 'icom-wlan-node/utils/errorHandling';
+ *
+ * // 在应用启动时调用（可选）
+ * setupGlobalErrorHandlers({
+ *   onUnhandledRejection: (reason, promise) => {
+ *     console.error('未处理的 Promise rejection:', reason);
+ *     // 自定义处理逻辑
+ *   },
+ *   onUncaughtException: (error, origin) => {
+ *     console.error('未捕获的异常:', error);
+ *     // 自定义处理逻辑
+ *   }
+ * });
+ * ```
+ */
+export interface GlobalErrorHandlerOptions {
+    /**
+     * 处理未捕获的 Promise rejection
+     * @param reason - rejection 的原因
+     * @param promise - 被 reject 的 Promise
+     */
+    onUnhandledRejection?: (reason: any, promise: Promise<any>) => void;
+    /**
+     * 处理未捕获的异常
+     * @param error - 异常对象
+     * @param origin - 异常来源 ('uncaughtException' 或 'unhandledRejection')
+     */
+    onUncaughtException?: (error: Error, origin: string) => void;
+    /**
+     * 是否在处理错误后阻止进程退出（默认 true）
+     * 设为 false 时，错误会被记录但进程仍可能退出
+     */
+    preventExit?: boolean;
+}
+/**
+ * 设置全局错误处理器
+ *
+ * 注意：这是一个可选的工具函数，仅在需要时使用。
+ * 如果你的应用已经有全局错误处理逻辑，不需要调用此函数。
+ *
+ * @param options - 错误处理选项
+ * @returns cleanup 函数，用于移除错误处理器
+ */
+export declare function setupGlobalErrorHandlers(options?: GlobalErrorHandlerOptions): () => void;
+/**
+ * 快速设置：仅防止进程崩溃，使用默认错误处理
+ */
+export declare function setupBasicErrorProtection(): () => void;

package/dist/utils/errorHandling.js

@@ -0,0 +1,147 @@
+"use strict";
+/**
+ * 全局错误处理工具函数
+ *
+ * 这个模块提供可选的全局错误处理器，帮助用户防止未捕获的 Promise rejection 和异常导致进程崩溃。
+ *
+ * 使用方式：
+ * ```typescript
+ * import { setupGlobalErrorHandlers } from 'icom-wlan-node/utils/errorHandling';
+ *
+ * // 在应用启动时调用（可选）
+ * setupGlobalErrorHandlers({
+ *   onUnhandledRejection: (reason, promise) => {
+ *     console.error('未处理的 Promise rejection:', reason);
+ *     // 自定义处理逻辑
+ *   },
+ *   onUncaughtException: (error, origin) => {
+ *     console.error('未捕获的异常:', error);
+ *     // 自定义处理逻辑
+ *   }
+ * });
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupGlobalErrorHandlers = setupGlobalErrorHandlers;
+exports.setupBasicErrorProtection = setupBasicErrorProtection;
+/**
+ * 设置全局错误处理器
+ *
+ * 注意：这是一个可选的工具函数，仅在需要时使用。
+ * 如果你的应用已经有全局错误处理逻辑，不需要调用此函数。
+ *
+ * @param options - 错误处理选项
+ * @returns cleanup 函数，用于移除错误处理器
+ */
+function setupGlobalErrorHandlers(options = {}) {
+    const { onUnhandledRejection = defaultUnhandledRejectionHandler, onUncaughtException = defaultUncaughtExceptionHandler, preventExit = true } = options;
+    // 未处理的 Promise rejection 处理器
+    const unhandledRejectionHandler = (reason, promise) => {
+        console.error('⚠️  [icom-wlan-node] 检测到未处理的 Promise rejection:');
+        console.error('原因:', reason);
+        console.error('Promise:', promise);
+        if (reason instanceof Error) {
+            console.error('错误堆栈:', reason.stack);
+        }
+        // 调用用户自定义处理器
+        onUnhandledRejection(reason, promise);
+    };
+    // 未捕获的异常处理器
+    const uncaughtExceptionHandler = (error, origin) => {
+        console.error('⚠️  [icom-wlan-node] 检测到未捕获的异常:');
+        console.error('错误:', error);
+        console.error('来源:', origin);
+        console.error('堆栈:', error.stack);
+        // 调用用户自定义处理器
+        onUncaughtException(error, origin);
+        // 根据配置决定是否退出
+        if (!preventExit) {
+            console.error('进程即将退出...');
+            process.exit(1);
+        }
+    };
+    // 注册处理器
+    process.on('unhandledRejection', unhandledRejectionHandler);
+    process.on('uncaughtException', uncaughtExceptionHandler);
+    console.log('✓ [icom-wlan-node] 全局错误处理器已设置');
+    // 返回 cleanup 函数
+    return () => {
+        process.off('unhandledRejection', unhandledRejectionHandler);
+        process.off('uncaughtException', uncaughtExceptionHandler);
+        console.log('✓ [icom-wlan-node] 全局错误处理器已移除');
+    };
+}
+/**
+ * 默认的未处理 Promise rejection 处理器
+ */
+function defaultUnhandledRejectionHandler(reason, promise) {
+    // 检查是否是网络错误（可以优雅处理）
+    if (isNetworkError(reason)) {
+        console.warn('网络错误已被捕获，但未影响进程稳定性');
+        return;
+    }
+    // 其他错误记录为警告
+    console.warn('检测到未处理的 Promise rejection，但进程继续运行');
+}
+/**
+ * 默认的未捕获异常处理器
+ */
+function defaultUncaughtExceptionHandler(error, origin) {
+    // 检查是否是可恢复的错误
+    if (isRecoverableError(error)) {
+        console.warn('可恢复的错误已被捕获，进程继续运行');
+        return;
+    }
+    console.error('检测到严重错误，建议检查应用逻辑');
+}
+/**
+ * 判断是否是网络错误
+ */
+function isNetworkError(error) {
+    if (!error)
+        return false;
+    const networkErrorCodes = [
+        'EHOSTDOWN',
+        'EHOSTUNREACH',
+        'ENETDOWN',
+        'ENETUNREACH',
+        'ECONNREFUSED',
+        'ECONNRESET',
+        'ETIMEDOUT',
+        'ENOTFOUND'
+    ];
+    // 检查错误码
+    if (error.code && networkErrorCodes.includes(error.code)) {
+        return true;
+    }
+    // 检查错误消息
+    if (error.message && typeof error.message === 'string') {
+        return networkErrorCodes.some(code => error.message.includes(code));
+    }
+    return false;
+}
+/**
+ * 判断是否是可恢复的错误
+ */
+function isRecoverableError(error) {
+    // 网络错误通常是可恢复的
+    if (isNetworkError(error)) {
+        return true;
+    }
+    // 连接相关的错误也是可恢复的
+    const recoverableMessages = [
+        'Connection failed',
+        'User disconnect',
+        'Connection timeout',
+        'CIV/Audio sessions timeout'
+    ];
+    return recoverableMessages.some(msg => error.message.includes(msg));
+}
+/**
+ * 快速设置：仅防止进程崩溃，使用默认错误处理
+ */
+function setupBasicErrorProtection() {
+    return setupGlobalErrorHandlers({
+        preventExit: true
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "icom-wlan-node",
-  "version": "0.2.2",
+  "version": "0.2.3",
   "description": "Icom WLAN (CI‑V, audio) protocol implementation for Node.js/TypeScript.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",