Maintenance 9.x to master

CLAUDE.md

@@ -0,0 +1,128 @@
+# INAV Configurator - Developer Guide
+
+> **Maintainers:** Update this file when making architectural changes or adding major features.
+
+## Overview
+
+INAV Configurator is a cross-platform Electron desktop application for configuring INAV flight controllers. It supports multirotors, fixed-wing aircraft, rovers, and boats.
+
+**Tech Stack:** Electron + Vite + jQuery + i18next
+
+## Quick Start
+
+```bash
+yarn install    # Install dependencies
+yarn start      # Run in development mode (hot reload)
+yarn make       # Build distributable packages
+```
+
+## Directory Structure
+
+```
+inav-configurator/
+├── js/                     # Main application source
+│   ├── configurator_main.js    # Renderer entry point (initializes UI)
+│   ├── fc.js                   # Flight controller state model
+│   ├── gui.js                  # Tab switching & UI management
+│   ├── msp.js                  # MSP protocol encoder/decoder
+│   ├── serial_backend.js       # Connection orchestration
+│   ├── main/                   # Electron main process
+│   │   ├── main.js                 # Main process entry
+│   │   └── preload.js              # IPC bridge (renderer↔main)
+│   ├── connection/             # Connection layer (factory pattern)
+│   │   ├── connectionSerial.js     # Serial port
+│   │   ├── connectionTcp.js        # TCP/IP (SITL)
+│   │   └── connectionBle.js        # Bluetooth LE
+│   ├── msp/                    # MSP protocol helpers
+│   │   ├── MSPCodes.js             # Command codes
+│   │   └── MSPHelper.js            # Serialization (largest file)
+│   └── transpiler/             # Logic conditions compiler
+├── src/css/                # Stylesheets
+│   └── tabs/                   # Per-tab styles
+├── locale/                 # i18n translations (en, ja, uk, zh_CN)
+├── resources/              # 3D models, OSD fonts, SITL binaries
+├── index.html              # Single-page app entry
+├── forge.config.js         # Electron Forge build config
+└── vite.*.config.js        # Vite build configs
+```
+
+## Architecture
+
+### Data Flow
+
+```
+User → GUI Tab → MSP.send_message() → Serial Queue → Connection → Flight Controller
+                                                                         ↓
+User ← GUI Update ← FC state object ← MSP.decode() ← Serial Data ←──────┘
+```
+
+### Key Subsystems
+
+1. **Connection Layer** (`js/connection/`): Factory pattern abstracts serial, TCP, UDP, BLE
+2. **MSP Protocol** (`js/msp/`): Binary protocol for FC communication (V1/V2 variants)
+3. **FC State** (`js/fc.js`): Central state object (CONFIG, PID, SENSOR_DATA, GPS_DATA, etc.)
+4. **Tab System** (`js/gui.js`): Tabs load dynamically; separate tabs for connected vs disconnected states
+
+### MSP Request Pattern
+
+```javascript
+MSP.send_message(MSPCodes.MSP_SOME_CODE, payload, false, () => {
+    // FC state already updated, refresh UI here
+    updateUIFromState(FC.SOME_DATA);
+});
+```
+
+## Adding a New Tab
+
+1. Create tab JS file with `initialize()` and `cleanup()` functions
+2. Register in `TABS` object
+3. Add CSS in `src/css/tabs/`
+4. Add HTML link in `index.html` (mode-connected or mode-disconnected list)
+5. Add translation keys to `locale/en/messages.json`
+
+## Adding New MSP Commands
+
+1. Add command code to `js/msp/MSPCodes.js`
+2. Add serialize/deserialize logic to `js/msp/MSPHelper.js`
+3. Add state property to `js/fc.js`
+4. Use in relevant tab
+
+## Build Targets
+
+| Platform | Command | Output |
+|----------|---------|--------|
+| Windows  | `yarn make --platform win32` | MSI installer |
+| macOS    | `yarn make --platform darwin` | DMG |
+| Linux    | `yarn make --platform linux` | DEB, RPM |
+
+## Key Files by Importance
+
+| File | Purpose |
+|------|---------|
+| `js/msp/MSPHelper.js` | All MSP serialization (159KB - largest file) |
+| `js/fc.js` | Flight controller state model |
+| `js/serial_backend.js` | Connection management |
+| `js/gui.js` | Tab switching, UI state |
+| `js/configurator_main.js` | Application initialization |
+
+
+## Code Patterns
+
+- **jQuery** for DOM manipulation
+- **Callbacks** for async (some Promises)
+- **i18next** via `data-i18n` attributes: `<span data-i18n="key"></span>`
+- **ES6 modules** throughout (`import`/`export`)
+
+## Debugging
+
+```bash
+NODE_ENV=development yarn start   # Dev mode
+# Press Ctrl+Shift+I for DevTools
+```
+
+## Resources
+
+- [INAV Firmware](https://github.com/iNavFlight/inav)
+- [INAV Wiki](https://github.com/iNavFlight/inav/wiki)
+- [INAV Discord](https://discord.gg/peg2hhbYwN)
+- [Electron Docs](https://www.electronjs.org/docs)

forge.config.js

@@ -9,6 +9,39 @@ export default {
     executableName: "inav-configurator",
     asar: false,
     icon: 'images/inav',
+    extraResource: [
+      'resources/public/sitl'
+    ],
+    afterCopy: [
+      (buildPath, electronVersion, platform, arch, callback) => {
+        // Remove SITL binaries for other platforms/architectures to reduce package size
+        const sitlPath = path.join(buildPath, 'resources', 'sitl');
+        if (platform === 'win32') {
+          fs.rmSync(path.join(sitlPath, 'linux'), { recursive: true, force: true });
+          fs.rmSync(path.join(sitlPath, 'macos'), { recursive: true, force: true });
+        } else if (platform === 'darwin') {
+          fs.rmSync(path.join(sitlPath, 'linux'), { recursive: true, force: true });
+          fs.rmSync(path.join(sitlPath, 'windows'), { recursive: true, force: true });
+        } else if (platform === 'linux') {
+          fs.rmSync(path.join(sitlPath, 'macos'), { recursive: true, force: true });
+          fs.rmSync(path.join(sitlPath, 'windows'), { recursive: true, force: true });
+          // Remove wrong architecture
+          if (arch === 'x64') {
+            fs.rmSync(path.join(sitlPath, 'linux', 'arm64'), { recursive: true, force: true });
+          } else if (arch === 'arm64') {
+            // Move arm64 binary to linux root and remove x64
+            const arm64Binary = path.join(sitlPath, 'linux', 'arm64', 'inav_SITL');
+            const destBinary = path.join(sitlPath, 'linux', 'inav_SITL');
+            if (fs.existsSync(arm64Binary)) {
+              fs.rmSync(destBinary, { force: true });
+              fs.renameSync(arm64Binary, destBinary);
+              fs.rmSync(path.join(sitlPath, 'linux', 'arm64'), { recursive: true, force: true });
+            }
+          }
+        }
+        callback();
+      }
+    ],
   },
   rebuildConfig: {},
   plugins: [

js/configurator_main.js

@@ -300,6 +300,15 @@ $(function() {
                         var check = $(this).is(':checked');
                         store.set('update_notify', check);
                     });
+
+                    if (store.get('disable_3d_acceleration', false)) {
+                        $('div.disable_3d_acceleration input').prop('checked', true);
+                    }
+
+                     $('div.disable_3d_acceleration input').on('change', function () {
+                        var check = $(this).is(':checked');
+                        store.set('disable_3d_acceleration', check);
+                    });
 
                     $('div.statistics input').on('change', function () {
                         var check = $(this).is(':checked');

js/main/main.js

@@ -14,6 +14,19 @@ import child_process from './child_process';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 
+/**
+ * Returns the base path for SITL binaries.
+ * - In packaged mode: uses Electron's resourcesPath (where extraResource files are placed)
+ * - In dev mode: uses the source location in resources/public/sitl
+ */
+function getSitlBasePath() {
+  if (app.isPackaged) {
+    return path.join(process.resourcesPath, 'sitl');
+  } else {
+    return path.join(app.getAppPath(), 'resources', 'public', 'sitl');
+  }
+}
+
 const usbBootloaderIds =  [
   { vendorId: 1155, productId: 57105}, 
   { vendorId: 11836, productId: 57105}
@@ -31,11 +44,21 @@ let selectBluetoothCallback = null;
 
 const store = new Store();
 
-// Workaround for some Linux systems: https://github.com/electron/electron/issues/32760 
-if (process.platform === 'linux') {
+// Workaround for some Linux systems: https://github.com/electron/electron/issues/32760
+if (store.get('disable_3d_acceleration', false)) {
   app.disableHardwareAcceleration();
 }
 
+// Enable remote debugging in development mode
+// This allows chrome://inspect and Playwright CDP connections
+if (!app.isPackaged) {  // Development mode (not packaged)
+  const port = process.env.CDP_PORT ?? '9222';
+  app.commandLine.appendSwitch('remote-debugging-port', port);
+  console.log(`[cdp] Remote debugging enabled on port ${port}`);
+  console.log(`   Chrome DevTools: chrome://inspect`);
+  console.log(`   CDP Endpoint: http://localhost:${port}`);
+}
+
 // In Electron the bluetooth device chooser didn't exist, so we have to build our own
 function createDeviceChooser() {
   bluetoothDeviceChooser = new BrowserWindow({
@@ -340,7 +363,7 @@ app.whenReady().then(() => {
 
   ipcMain.handle('chmod', (_event, pathName, mode) => {
     return new Promise(resolve => {
-      chmod(path.join(__dirname, 'sitl', pathName), mode, error => {
+      chmod(path.join(getSitlBasePath(), pathName), mode, error => {
         if (error) {
           resolve(error.message)
         } else {
@@ -363,7 +386,7 @@ app.whenReady().then(() => {
   });
 
   ipcMain.on('startChildProcess', (_event, command, args, opts) => {
-    child_process.start(path.join(__dirname, 'sitl', command), args, opts, mainWindow);
+    child_process.start(path.join(getSitlBasePath(), command), args, opts, mainWindow);
   });
 
   ipcMain.on('killChildProcess', (_event) => {

js/main/serial.js

@@ -9,13 +9,49 @@ const serial = {
     _serialport: null,
     _id: 1,
 
-    connect: function(path, options, window) {
+    connect: async function(path, options, window) {
+        // Clean up any existing serial port to prevent handle leaks
+        if (this._serialport) {
+            try {
+                const oldPort = this._serialport;
+                this._serialport = null;
+                oldPort.removeAllListeners();
+                if (oldPort.isOpen) {
+                    await new Promise(resolveClose => {
+                        oldPort.close(() => resolveClose());
+                    });
+                }
+                oldPort.destroy();
+                // Small delay to ensure OS releases the file handle
+                await new Promise(r => setTimeout(r, 100));
+            } catch (e) {
+                console.log('Cleanup error (ignored):', e.message);
+            }
+        }
+
         return new Promise(resolve => {
             try {
+                var openPortResolved = false;
                 this._serialport = new SerialPortStream({binding, path: path, baudRate: options.bitrate, autoOpen: true});
                 this._serialport.on('error', error => {
+                    console.log('Serial port error:', error.message);
                     if (!window.isDestroyed()) {
-                        window.webContents.send('serialError', error); 
+                        window.webContents.send('serialError', error);
+                    }
+
+                    // Clean up the serial port to prevent handle leaks
+                    // This prevents "Resource temporarily unavailable Cannot lock port" errors
+                    if (this._serialport) {
+                        const failedPort = this._serialport;
+                        this._serialport = null;
+                        failedPort.removeAllListeners();
+                        failedPort.destroy();
+                    }
+
+                    if(!openPortResolved) {
+                        openPortResolved = true;
+                        // Fixed: Report error correctly so connection handling works properly
+                        resolve({error: true, msg: error.message || 'Serial port error'});
                     }
                 });
 
@@ -30,7 +66,12 @@ const serial = {
                         window.webContents.send('serialData', buffer);
                     }
                 });
-                resolve({error: false, id: this._id++});
+
+                this._serialport.on('open', () => {
+                    openPortResolved = true;
+                    resolve({error: false, id: this._id++});
+                });
+
             } catch (err) {
                 resolve ({error: true, errorMsg: err});
             }
@@ -39,14 +80,24 @@ const serial = {
     close: function() {
         return new Promise(resolve => {
             if (this._serialport && this._serialport.isOpen) {
-                this._serialport.close(error => {
+                const port = this._serialport;
+                this._serialport = null;
+                port.close(error => {
                     if (error) {
                         resolve({error: true, msg: error})
                     } else {
                         resolve({error: false})
                     }
                 });
+            } else if (this._serialport) {
+                // Port exists but isn't open - destroy it to clean up
+                try {
+                    this._serialport.destroy();
+                } catch (e) {
+                    // Ignore cleanup errors
+                }
                 this._serialport = null;
+                resolve({error: false});
             } else {
                 resolve({error: false})
             }

js/msp/MSPCodes.js

@@ -217,7 +217,8 @@ var MSPCodes = {
     MSP2_INAV_SAFEHOME:                 0x2038,
     MSP2_INAV_SET_SAFEHOME:             0x2039,
 
-    MSP2_INAV_LOGIC_CONDITIONS_SINGLE:  0x203B,
+    MSP2_INAV_LOGIC_CONDITIONS_SINGLE:      0x203B,
+    MSP2_INAV_LOGIC_CONDITIONS_CONFIGURED:  0x203C,
 
     MSP2_INAV_LED_STRIP_CONFIG_EX:      0x2048,
     MSP2_INAV_SET_LED_STRIP_CONFIG_EX:  0x2049,