@noforeignland/signalk-to-noforeignland 1.1.0-beta.2 → 1.1.0

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 1.1.0
+* CHANGE: Removed postinstall script - SignalK server will use --ignore-scripts (issue #2181). Runtime PluginCleanup handles all migration.
 * CHANGE: Refactored Project structure, see PROJECT_STRUCTURE.md
+* CHANGE: Use phrase GNSS instead of GPS - Thanks Piotr
+* BUGFIX: Removed unreliable DNS-based internet connectivity test (beta.11) - API retry logic is sufficient
+* BUGFIX: Reverted to beta.3 working configuration (beta.10) - undoing all failed schema experiments from beta.4-9
+* CHANGE: Improved cleanup error handling - only shows error after all retry attempts fail
+* CHANGE: Added installed plugins logging for better debugging
+* CHANGE: Platform-specific cleanup instructions (Cerbo GX vs standard)
 
 1.0.1
 * CHANGE: Cleanup previous installs and migrate plugin config, removes depricated old plugins.
@@ -27,17 +34,17 @@ The "new" one has to be installed once manually, after that everything is back t
 0.1.29-beta.1
 * CHANGE: After talking to Treppo from Sugnal K core team we should use the data path "noforeignland.*", code and docs changed.
 * CHANGE: README.md info added and format optimized
-* CHANGE: GPS source at the end for setPluginStatus - Cerbo has a long source name and truncates it.
+* CHANGE: GNSS source at the end for setPluginStatus - Cerbo has a long source name and truncates it.
 * CHANGE: Use "npm install instead" of "npm ci" to push from Github to npmjs using OIDC authentication
 * CHANGE: Moved navigation.position source from path noforeignland.status to noforeignland.source
 
 0.1.28
-* BUGFIX: No GPS data found - introduced in 0.1.27 - Thanks Piotr
+* BUGFIX: No GNSS data found - introduced in 0.1.27 - Thanks Piotr
 
 0.1.28-beta.2
 * EXPERIMENTAL: Signal K data path to visualize the plugin behaviour or error in Node Red, KIP, etc. Using plugin.signalk-to-noforeignland.* for now. See README.md for details.
 * CHANGE: Using app.getDataDirPath() to store transient data, thanks Jeremy, they are now in "plugin-config-data/signalk-to-noforeignland/nfl-track" and renamed to pending.json1 and sent.json1
-* CHANGE: Optimize GPS detection if multiple navigation.position from different sources exist.
+* CHANGE: Optimize GNSS detection if multiple navigation.position from different sources exist.
 * CHANGE: PluginStatus optimized for limited space available.
 * CHANGE: doc/beta_install.md changed for new file structure.
 
@@ -49,13 +56,13 @@ The "new" one has to be installed once manually, after that everything is back t
 
 0.1.27-beta.1
 * NEW: NPMJS requires new method for publishing. The old tokens will expire Nov 19th, 2025, so moving to OIDC authentication.
-* NEW: Check the GPS status in navigation.position, else retry and throw PluginError on Dashboard
+* NEW: Check the GNSS status in navigation.position, else retry and throw PluginError on Dashboard
 * CHANGE: Keep track data on disk rewritten and migrate old files to new structure, so nfl-track-sent.jsonl becomes a continuous archive of all sent track data over time, when enabled. New Logic:
     * New points accumulate in nfl-track-pending.jsonl
     * Send succeeds → API confirms receipt
     * If keepFiles=true: The content of pending file is appended to nfl-track-sent.jsonl (line 588)
     * Pending file is deleted
-    * Next GPS points → create a new pending file
+    * Next GNSS points → create a new pending file
     * Next successful send → appends again to the same nfl-track-sent.jsonl
 
 0.1.26

package/PROJECT_STRUCTURE.md

@@ -0,0 +1,357 @@
+# Project Structure
+
+This document describes the architecture and organization of the SignalK to Noforeignland plugin.
+
+## Overview
+
+This plugin follows a modular architecture where each responsibility is encapsulated in a dedicated module. The main orchestrator ([index.js](index.js)) coordinates all modules through a class-based approach.
+
+## Directory Layout
+
+```
+nfl-signalk/
+  index.js                      # Main plugin entry point & orchestrator
+  cleanup-old-plugin.js         # Postinstall script for removing old versions
+  package.json                  # NPM package configuration
+  lib/                          # Core modules directory
+    ConfigManager.js            # Configuration handling & migration
+    TrackLogger.js              # Position subscription & logging
+    TrackSender.js              # API communication & track sending
+    HealthMonitor.js            # Position data health checks
+    PluginCleanup.js            # Runtime cleanup of old plugins
+    TrackMigration.js           # Track file migration utilities
+    DataPathEmitter.js          # SignalK delta emission
+    DirectoryUtils.js           # File system utilities
+  README.md                     # User documentation
+  CHANGELOG.md                  # Version history
+  PROJECT_STRUCTURE.md          # This file
+```
+
+## Module Responsibilities
+
+### Core Orchestrator
+
+#### [index.js](index.js)
+**Purpose**: Main plugin class that orchestrates all modules and implements SignalK plugin lifecycle.
+
+**Key Responsibilities**:
+- Exports SignalK plugin object with `start()` and `stop()` methods
+- Initializes all module instances in correct order
+- Manages plugin state (options, upSince, cron, lastSuccessfulTransfer)
+- Coordinates between modules during startup sequence
+- Handles plugin status and error reporting to SignalK UI
+- Implements CRON-based interval for data sending
+
+**Key Methods**:
+- `start(options, restartPlugin)`: 13-step startup sequence
+- `stop()`: Cleanup and shutdown
+- `interval()`: CRON job handler for sending tracks
+- `handleSavePoint(lastPosition)`: Callback when track point is saved
+- `handleHealthy()`: Callback when health check passes
+- `setPluginStatus(status)`: Update UI status
+- `setPluginError(error)`: Report error to UI
+
+### Configuration & Migration
+
+#### [lib/ConfigManager.js](lib/ConfigManager.js)
+**Purpose**: Handles plugin configuration, schema definition, and config migration.
+
+**Key Responsibilities**:
+- Defines plugin schema (mandatory/advanced/expert settings groups)
+- Migrates old flat config structure to new nested structure
+- Flattens nested config back to internal format with defaults
+- Validates boat API key
+- Resolves track directory paths (absolute vs relative)
+- Randomizes CRON schedule to avoid server load spikes
+
+**Config Structure**:
+```javascript
+{
+  mandatory: { boatApiKey: string },
+  advanced: { minMove, minSpeed, sendWhileMoving, ping_api_every_24h },
+  expert: { filterSource, trackDir, keepFiles, trackFrequency, apiCron,
+            internetTestTimeout, apiTimeout }
+}
+```
+
+### Position Tracking
+
+#### [lib/TrackLogger.js](lib/TrackLogger.js)
+**Purpose**: Subscribes to position updates and logs them to disk.
+
+**Key Responsibilities**:
+- Subscribes to `navigation.position` and optionally `navigation.speedOverGround`
+- Implements GNSS source auto-selection (stick to one source unless stale)
+- Supports manual source filtering via `filterSource` config
+- Validates positions (rejects coordinates near 0,0)
+- Applies movement filters (minSpeed, minMove, trackFrequency)
+- Implements 24-hour keepalive ping
+- Saves track points to JSONL file (`pending.jsonl`)
+- Calculates distances using equirectangular approximation
+
+**GNSS Source Logic**:
+- If `filterSource` is set: only accept that specific source
+- If not set: auto-select first source, switch only if stale (>5 min)
+- Prevents position jumps when multiple GNSS devices are present
+
+**Track Point Format**:
+```json
+{"lat": 37.8136, "lon": -122.4784, "t": "2025-01-15T10:30:00.000Z"}
+```
+
+#### [lib/TrackSender.js](lib/TrackSender.js)
+**Purpose**: Sends accumulated track data to the Noforeignland API.
+
+**Key Responsibilities**:
+- Reads track points from `pending.jsonl`
+- Tests internet connectivity via DNS lookups (8.8.8.8, 1.1.1.1)
+- Checks if boat is moving (based on last position timestamp)
+- Sends track data to NFL API with retry logic (3 attempts)
+- Handles successful sends (archive to `sent.jsonl` or delete)
+- Validates position coordinates before sending
+
+**API Request Format**:
+```javascript
+POST https://www.noforeignland.com/home/api/v1/boat/tracking/track
+Headers: { 'X-NFL-API-Key': pluginApiKey }
+Body: {
+  timestamp: ms,
+  track: [[ms, lat, lon], [ms, lat, lon], ...],
+  boatApiKey: userBoatApiKey
+}
+```
+
+**Retry Logic**:
+- Attempt 1: base timeout (default 30s)
+- Attempt 2: 2x timeout + 2s delay
+- Attempt 3: 3x timeout + 4s delay
+
+### Health & Monitoring
+
+#### [lib/HealthMonitor.js](lib/HealthMonitor.js)
+**Purpose**: Monitors GNSS position data freshness and reports issues.
+
+**Key Responsibilities**:
+- Initial check: 2 minutes after startup
+- Periodic checks: every 5 minutes
+- Detects stale position data (>5 minutes old)
+- Detects missing position data
+- Provides context-aware error messages (filtered vs auto-selected source)
+- Calls error/healthy callbacks to update plugin status
+
+**Health States**:
+- Healthy: Position received within last 5 minutes
+- Warning: No position for >5 minutes
+- Error: No position ever received (or 2+ min after startup)
+
+### Cleanup & Migration
+
+#### [lib/PluginCleanup.js](lib/PluginCleanup.js)
+**Purpose**: Runtime cleanup of old plugin versions.
+
+**Key Responsibilities**:
+- Detects Victron Cerbo vs standard SignalK paths
+- Migrates config from old `signalk-to-noforeignland` to new scoped name
+- Removes old plugin directories (`signalk-to-noforeignland`, `signalk-to-nfl`)
+- Multiple retry attempts (immediate, 5s, 15s, 30s delays)
+- Falls back to manual instructions if removal fails
+- Returns promise resolving to 'all_removed' or 'partial_removal'
+
+**Old Plugins Removed**:
+- `signalk-to-noforeignland` (unscoped predecessor)
+- `signalk-to-nfl` (deprecated alias)
+
+#### [cleanup-old-plugin.js](cleanup-old-plugin.js)
+**Purpose**: Postinstall script for immediate cleanup during npm install.
+
+**Key Responsibilities**:
+- Runs via `npm postinstall` hook
+- Uses direct `fs.rmSync()` instead of npm uninstall (safer during install)
+- 2-second delay to allow npm to complete current operation
+- Detects Victron Cerbo vs standard SignalK paths
+- Migrates config files
+- Provides fallback manual instructions
+
+**Why Two Cleanup Mechanisms?**
+1. **Postinstall**: Runs during installation, removes old plugins immediately
+2. **Runtime**: Handles cases where postinstall failed (permissions, timing)
+
+#### [lib/TrackMigration.js](lib/TrackMigration.js)
+**Purpose**: Migrates track files from old naming/location schemes.
+
+**Key Responsibilities**:
+- Migrates old file names to new naming scheme:
+  - `nfl-track.jsonl` -> `pending.jsonl`
+  - `nfl-track-pending.jsonl` -> `pending.jsonl`
+  - `nfl-track-sent.jsonl` -> `sent.jsonl`
+- Migrates track files from old plugin directory to new data directory
+- Removes old track directory if empty
+- Non-destructive: only migrates if target doesn't exist
+
+### SignalK Integration
+
+#### [lib/DataPathEmitter.js](lib/DataPathEmitter.js)
+**Purpose**: Creates and updates SignalK data paths for external integrations.
+
+**Key Responsibilities**:
+- Emits SignalK deltas to create data paths
+- Updates status paths on state changes
+- Manages error state independently
+- Provides both ISO8601 and locale-formatted timestamps
+
+**Data Paths Created**:
+```
+noforeignland.savepoint             # ISO8601 timestamp of last save
+noforeignland.savepoint_local       # Locale string of last save
+noforeignland.sent_to_api           # ISO8601 timestamp of last API transfer
+noforeignland.sent_to_api_local     # Locale string of last API transfer
+noforeignland.status                # Status string (save/transfer/source info)
+noforeignland.status_boolean        # 0 = OK, 1 = error
+noforeignland.source                # Active GNSS source name
+```
+
+**Usage**: These paths can be consumed by Node-RED, KIP dashboards, or other SignalK consumers.
+
+#### [lib/DirectoryUtils.js](lib/DirectoryUtils.js)
+**Purpose**: File system utilities with proper error handling.
+
+**Key Responsibilities**:
+- Creates directories recursively
+- Checks read/write permissions
+- Provides context-specific error messages
+- Handles common error codes (EACCES, EPERM, ETIMEDOUT)
+
+## Data Flow
+
+### Startup Sequence
+```
+1. ConfigManager: Migrate old config -> flatten -> validate
+2. DirectoryUtils: Create track directory
+3. PluginCleanup: Remove old plugins (async, non-blocking)
+4. TrackMigration: Migrate old track files
+5. Initialize: TrackLogger, TrackSender, HealthMonitor
+6. ConfigManager: Randomize CRON schedule
+7. TrackLogger: Start position subscription
+8. CRON: Start interval job
+9. HealthMonitor: Start health checks
+```
+
+### Position Logging Flow
+```
+navigation.position delta
+  -> TrackLogger.doOnValue()
+    -> handleSourceSelection() [filter/auto-select]
+    -> isValidPosition() [validate lat/lon]
+    -> shouldLogPosition() [check distance/frequency]
+    -> savePoint() [append to pending.jsonl]
+    -> callback to index.handleSavePoint()
+      -> DataPathEmitter.emitSavepoint()
+      -> setPluginStatus()
+```
+
+### Track Sending Flow (CRON Interval)
+```
+CRON trigger
+  -> index.interval()
+    -> TrackSender.isBoatMoving() [check last position age]
+    -> TrackSender.hasTrackData() [check pending.jsonl exists]
+    -> TrackSender.testInternet() [DNS lookup test]
+    -> TrackSender.sendTrack()
+      -> createTrackFromFile() [read pending.jsonl]
+      -> sendWithRetry() [POST to API, 3 attempts]
+      -> handleSuccessfulSend() [archive or delete]
+    -> DataPathEmitter.emitApiTransfer()
+    -> setPluginStatus()
+```
+
+### Health Monitoring Flow
+```
+HealthMonitor timer (every 5 min)
+  -> performHealthCheck()
+    -> check lastPositionReceived timestamp
+    -> if stale/missing: call onError callback
+      -> index.setPluginError()
+        -> DataPathEmitter.setError()
+        -> app.setPluginError()
+    -> if healthy: call onHealthy callback
+      -> index.handleHealthy()
+        -> setPluginStatus() [clear error if needed]
+```
+
+## File Locations
+
+### Victron Cerbo GX
+- SignalK directory: `/data/conf/signalk`
+- Plugin installed at: `/data/conf/signalk/node_modules/@noforeignland/signalk-to-noforeignland`
+- Config: `/data/conf/signalk/plugin-config-data/@noforeignland-signalk-to-noforeignland.json`
+- Track files: `/data/conf/signalk/plugin-config-data/@noforeignland-signalk-to-noforeignland/nfl-track/`
+
+### Standard SignalK
+- SignalK directory: `~/.signalk`
+- Plugin installed at: `~/.signalk/node_modules/@noforeignland/signalk-to-noforeignland`
+- Config: `~/.signalk/plugin-config-data/@noforeignland-signalk-to-noforeignland.json`
+- Track files: `~/.signalk/plugin-config-data/@noforeignland-signalk-to-noforeignland/nfl-track/`
+
+## Development Notes
+
+### Adding New Features
+1. Create module in `lib/` if it's a distinct responsibility
+2. Instantiate in [index.js](index.js) constructor
+3. Initialize in `start()` method at appropriate step
+4. Clean up in `stop()` method
+5. Update this document
+
+### Configuration Changes
+1. Update schema in [ConfigManager.js](lib/ConfigManager.js) `getSchema()`
+2. Add migration logic in `migrateOldConfig()` if breaking change
+3. Update `flattenConfig()` to include new fields with defaults
+4. Test both old and new config formats
+
+### Track File Format Changes
+1. Update `TrackLogger.savePoint()` for writing
+2. Update `TrackSender.createTrackFromFile()` for reading
+3. Add migration logic in [TrackMigration.js](lib/TrackMigration.js) if needed
+
+### Testing Checklist
+- [ ] Test on Victron Cerbo GX (path detection, limited storage)
+- [ ] Test on standard SignalK installation
+- [ ] Test config migration from old versions
+- [ ] Test with multiple GNSS sources (auto-selection)
+- [ ] Test with filtered source
+- [ ] Test with no internet connection
+- [ ] Test with slow internet (timeout scenarios)
+- [ ] Test cleanup of old plugins
+- [ ] Test track file migration
+
+## Dependencies
+
+```json
+{
+  "cron": "^2.1.0",           // CRON job scheduling
+  "fs-extra": "^10.1.0",      // Enhanced file system operations
+  "node-fetch": "^2.6.7"      // HTTP requests to API
+}
+```
+
+## Version History Notes
+
+- **1.1.0**: Refactored to modular structure
+- **1.0.x**: Scoped package name, cleanup mechanism
+- **0.1.x**: Original flat structure (deprecated)
+
+## Known Technical Debt
+
+1. **Empty process.exit()**: [cleanup-old-plugin.js](cleanup-old-plugin.js) setTimeout may not complete
+2. **Error timing**: [PluginCleanup.js](lib/PluginCleanup.js) shows error before retries complete
+3. **No test suite**: Manual testing only, no automated tests
+
+## SignalK Plugin Conventions
+
+This plugin follows SignalK plugin conventions:
+- Exports function returning `{id, name, schema, start, stop}`
+- Uses `app.debug()` for logging
+- Uses `app.setPluginStatus()` and `app.setPluginError()` for UI feedback
+- Subscribes via `app.subscriptionmanager.subscribe()`
+- Emits deltas via `app.handleMessage(pluginId, delta)`
+- Config stored in `plugin-config-data/` directory
+- Data stored in plugin's data directory

package/README.md

@@ -1,9 +1,6 @@
 # Signal K To Noforeignland
 Effortlessly log your boat's movement to **noforeignland.com**
 
-## Important for 0.1.x users
-Upgrade to >1.0.1 by installing this plugin from the Appstore ageain. Your old config will be migrated.
-
 ## Features
 * Automatically log your position to noforeignland.com
 * Send detailed tracks to log your entire trip and not just your final position
@@ -14,12 +11,13 @@ Upgrade to >1.0.1 by installing this plugin from the Appstore ageain. Your old c
 * SK data paths about the plugin status for your own dashboard or Node Red coding
 
 ## Issues
-* Server -> Plugin Config -> Signal K to Noforeignland -> Enable debug log (top right)
-* Report issues on GitHub (https://github.com/noforeignland/nfl-signalk/issues)
+* Enable debug logging: Server -> Plugin Config -> Signal K to Noforeignland -> Enable debug log (top right)
+* Check logs: Server -> Server Log (in SignalK web UI)
+* Report issues on [GitHub](https://github.com/noforeignland/nfl-signalk/issues)
 
 ## Requirements
 * An internet connection is required in order to update noforeignland.com
-* A navigation.position data path inside Signal K for self, which is your current GPS position
+* A navigation.position data path inside Signal K for self, which is your current GNSS position
 * A **noforeignland.com** account
 * Your Boat API Key from the **noforeignland.com** website: 
   * Account > Settings > Boat tracking > API Key
@@ -44,10 +42,11 @@ noforeignland.source - string              - string            - data source of
 notifications.noforeignland.status_boolean - json object       - auto created
 ```
 
-https://github.com/noforeignland/nfl-signalk/issues
-
 # Virctron Cerbo GX Users
 
 ## Limited storage
-Signal K can quickly exhaust the small onboard storage of the device, especially when a lot of logging is enabled. Vicron Energy addressed this here:
+Signal K can quickly exhaust the small onboard storage of the device, especially when a lot of logging is enabled and not properly configured. Even concider to not enable "Keep track files on disk" if you are moving a lot.
+
+Vicron Energy addressed this here:
 https://www.victronenergy.com/live/venus-os:large#disk_space_issues_data_partition_full
+

package/doc/beta_install_cerbo.md

@@ -84,9 +84,6 @@ chown -R signalk:signalk /data/conf/signalk/*
 ```
 
 
-----------------------------------------
-
-
 # dev tree (unstable) install - NOT RECOMMENDED
 
 1. Backup as above 
@@ -111,6 +108,20 @@ chown -R signalk:signalk /data/conf/signalk/*
 ```
 
 3. Restart Server & Check logs
+```
+svc -t /service/signalk-server
+```
+
+# Manual Fixes
+
+## WARNING: found multiple copies of plugin with id signalk-to-noforeignland at /data/conf/signalk/node_modules/ and /data/conf/signalk/node_modules/
+
+```
+cd /data/conf/signalk && npm uninstall signalk-to-noforeignland signalk-to-nfl
+```
+
+and than
+
 ```
 svc -t /service/signalk-server
 ```

package/index.js

@@ -202,17 +202,8 @@ class SignalkToNoforeignland {
       if (!hasTrack) {
         return;
       }
-      
-      // Test internet connection
-      const hasInternet = await this.trackSender.testInternet();
-      if (!hasInternet) {
-        const errorMsg = 'No internet connection detected. Unable to send tracking data to NFL. DNS lookups failed - check your internet connection.';
-        this.app.debug(errorMsg);
-        this.setPluginError(errorMsg);
-        return;
-      }
-      
-      // Send track data
+
+      // Send track data (has built-in retry logic)
       const success = await this.trackSender.sendTrack();
       
       if (success) {

package/lib/HealthMonitor.js

@@ -43,15 +43,15 @@ class HealthMonitor {
     
     if (!lastPositionReceived) {
       const errorMsg = this.options.filterSource
-        ? `No GPS position data received from filtered source '${this.options.filterSource}'. Check Expert Settings > Position source device, or leave empty to use any GPS source.`
-        : 'No GPS position data received. Check that your GPS is connected and SignalK is receiving navigation.position data.';
+        ? `No GNSS position data received from filtered source '${this.options.filterSource}'. Check Expert Settings > Position source device, or leave empty to use any GNSS source.`
+        : 'No GNSS position data received. Check that your GNSS is connected and SignalK is receiving navigation.position data.';
       
       onError(errorMsg);
       this.app.debug('Position health check: No position data ever received' + filterMsg);
     } else if (timeSinceLastPosition > 300) {
       const errorMsg = this.options.filterSource
-        ? `No GPS position data${filterMsg} for ${Math.floor(timeSinceLastPosition / 60)} minutes. Check that source '${this.options.filterSource}' is active, or change/clear Position source device in Expert Settings.`
-        : `No GPS position data${filterMsg} for ${Math.floor(timeSinceLastPosition / 60)} minutes. Check your GPS connection.`;
+        ? `No GNSS position data${filterMsg} for ${Math.floor(timeSinceLastPosition / 60)} minutes. Check that source '${this.options.filterSource}' is active, or change/clear Position source device in Expert Settings.`
+        : `No GNSS position data${filterMsg} for ${Math.floor(timeSinceLastPosition / 60)} minutes. Check your GNSS connection.`;
       
       onError(errorMsg);
       this.app.debug(`Position health check: No position for ${timeSinceLastPosition.toFixed(0)} seconds` + filterMsg);
@@ -68,8 +68,8 @@ class HealthMonitor {
     if (!lastPositionReceived) {
       const activeSource = this.options.filterSource || autoSelectedSource || 'any';
       const errorMsg = this.options.filterSource
-        ? `No GPS position data received after 2 minutes from filtered source '${this.options.filterSource}'. Check Expert Settings > Position source device. You may need to leave it empty to use any available GPS source.`
-        : 'No GPS position data received after 2 minutes. Check that your GPS is connected and SignalK is receiving navigation.position data.';
+        ? `No GNSS position data received after 2 minutes from filtered source '${this.options.filterSource}'. Check Expert Settings > Position source device. You may need to leave it empty to use any available GNSS source.`
+        : 'No GNSS position data received after 2 minutes. Check that your GNSS is connected and SignalK is receiving navigation.position data.';
       
       onError(errorMsg);
       this.app.debug('Initial position check: No position data received' + 

package/lib/PluginCleanup.js

@@ -13,37 +13,130 @@ class PluginCleanup {
     try {
       // Detect SignalK directory (standard or Victron Cerbo)
       const victronPath = '/data/conf/signalk';
-      const standardPath = process.env.SIGNALK_NODE_CONFIG_DIR || 
+      const standardPath = process.env.SIGNALK_NODE_CONFIG_DIR ||
                            path.join(process.env.HOME || process.env.USERPROFILE, '.signalk');
-      
+
       const configDir = fs.existsSync(victronPath) ? victronPath : standardPath;
       this.app.debug(`Using SignalK directory: ${configDir}`);
-      
+
       const configPath = path.join(configDir, 'plugin-config-data');
-      
+
       // 1. Config Migration - only from signalk-to-noforeignland
       await this.migrateConfig(configPath);
-      
-      // 2. Check and remove old plugins
-      await this.removeOldPlugins(configDir);
-      
+
+      // 2. Verify what plugins are actually present
+      this.logInstalledPlugins(configDir);
+
+      // 3. Check and remove old plugins
+      return await this.removeOldPlugins(configDir);
+
     } catch (err) {
       this.app.debug('Error during old plugin cleanup:', err.message);
+      return null;
+    }
+  }
+
+  /**
+   * Log which SignalK NFL plugins are currently installed (for debugging)
+   */
+  logInstalledPlugins(configDir) {
+    const nodeModulesDir = path.join(configDir, 'node_modules');
+    const pluginsToCheck = [
+      '@noforeignland/signalk-to-noforeignland',
+      'signalk-to-noforeignland',
+      'signalk-to-nfl'
+    ];
+
+    const found = [];
+    for (const pluginName of pluginsToCheck) {
+      const pluginPath = path.join(nodeModulesDir, pluginName);
+      if (fs.existsSync(pluginPath)) {
+        const packageJsonPath = path.join(pluginPath, 'package.json');
+        let version = 'unknown';
+        try {
+          if (fs.existsSync(packageJsonPath)) {
+            const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+            version = packageJson.version;
+          }
+        } catch (e) {
+          // Ignore version read errors
+        }
+        found.push(`${pluginName}@${version}`);
+      }
+    }
+
+    if (found.length > 0) {
+      this.app.debug(`Installed NFL plugins: ${found.join(', ')}`);
     }
   }
 
   /**
-   * Migrate config from old plugin to new scoped version
+   * Migrate config from old plugin ID to new plugin ID
+   *
+   * Handles config migration from:
+   * 1. Old unscoped plugin "signalk-to-noforeignland" (v0.1.x)
+   * 2. Beta versions with wrong plugin ID (v1.1.0-beta.1/2/3)
+   *
+   * Both used config filename: "signalk-to-noforeignland.json"
+   * New version uses: "@noforeignland-signalk-to-noforeignland.json"
+   *
+   * Since both sources use the same filename, we simply copy if it exists.
    */
   async migrateConfig(configPath) {
     const oldConfigFile = path.join(configPath, 'signalk-to-noforeignland.json');
     const newConfigFile = path.join(configPath, '@noforeignland-signalk-to-noforeignland.json');
-    
+
+    // Only migrate if old config exists and new config doesn't
     if (fs.existsSync(oldConfigFile) && !fs.existsSync(newConfigFile)) {
-      this.app.debug('Migrating configuration from old plugin "signalk-to-noforeignland"...');
-      fs.copyFileSync(oldConfigFile, newConfigFile);
-      fs.copyFileSync(oldConfigFile, `${oldConfigFile}.backup`);
-      this.app.debug('✓ Configuration migrated successfully');
+      this.app.debug('Migrating configuration from old plugin to new scoped plugin...');
+      this.app.debug(`  Source: ${oldConfigFile}`);
+      this.app.debug(`  Target: ${newConfigFile}`);
+
+      try {
+        // Copy to new location
+        fs.copyFileSync(oldConfigFile, newConfigFile);
+
+        // Create backup of old config
+        const backupFile = `${oldConfigFile}.backup-${Date.now()}`;
+        fs.copyFileSync(oldConfigFile, backupFile);
+
+        this.app.debug('✓ Configuration successfully migrated');
+        this.app.debug(`  Backup saved: ${backupFile}`);
+      } catch (err) {
+        this.app.debug(`⨯ Config migration failed: ${err.message}`);
+        this.app.debug('  You may need to reconfigure the plugin manually');
+      }
+    } else if (fs.existsSync(newConfigFile)) {
+      this.app.debug('Configuration already in new location');
+
+      // Check if config has incorrect "configuration" wrapper and fix it
+      try {
+        const configData = JSON.parse(fs.readFileSync(newConfigFile, 'utf8'));
+        if (configData.configuration && typeof configData.configuration === 'object') {
+          this.app.debug('Detected nested "configuration" wrapper, unwrapping...');
+
+          // Unwrap: move properties from configuration object to root
+          const unwrapped = {
+            ...configData.configuration,
+            enabled: configData.enabled,
+            enableLogging: configData.enableLogging,
+            enableDebug: configData.enableDebug
+          };
+
+          // Backup before fixing
+          const fixBackupFile = `${newConfigFile}.backup-unwrap-${Date.now()}`;
+          fs.copyFileSync(newConfigFile, fixBackupFile);
+
+          // Write fixed config
+          fs.writeFileSync(newConfigFile, JSON.stringify(unwrapped, null, 2));
+          this.app.debug('✓ Configuration unwrapped successfully');
+          this.app.debug(`  Backup: ${fixBackupFile}`);
+        }
+      } catch (err) {
+        this.app.debug(`⨯ Could not check/fix config structure: ${err.message}`);
+      }
+    } else {
+      this.app.debug('No old configuration found, first-time setup');
     }
   }
 
@@ -87,16 +180,11 @@ class PluginCleanup {
       this.app.debug('All old plugins removed successfully');
       return 'all_removed';
     }
-    
-    // Show warning for plugins that couldn't be removed immediately
+
+    // Don't show error immediately - log that we're retrying
     const stillPresentNames = stillPresent.map(p => `"${p.name}"`).join(' and ');
-    const stillPresentCmd = stillPresent.map(p => p.name).join(' ');
-    
-    this.app.setPluginError(
-      `Old plugin(s) ${stillPresentNames} still installed. ` +
-      `Will retry removal, or uninstall manually: cd ${configDir} && npm uninstall ${stillPresentCmd}`
-    );
-    
+    this.app.debug(`Old plugin(s) ${stillPresentNames} still present, will retry removal...`);
+
     // Delayed removal attempts (multiple tries with increasing delays)
     return new Promise((resolve) => {
       const delays = [5000, 15000, 30000]; // 5s, 15s, 30s
@@ -104,12 +192,22 @@ class PluginCleanup {
       
       const attemptRemoval = async () => {
         if (attemptIndex >= delays.length) {
-          // Final attempt failed
+          // Final attempt failed - NOW show error only if plugins still exist
           const remaining = stillPresent.filter(p => fs.existsSync(p.dir));
           if (remaining.length > 0) {
-            const remainingNames = remaining.map(p => p.name).join(' ');
-            this.app.debug(`Could not remove old plugins after multiple attempts: ${remainingNames}`);
-            this.app.debug(`Please manually run: cd ${configDir} && npm uninstall ${remainingNames}`);
+            const remainingNames = remaining.map(p => `"${p.name}"`).join(' and ');
+            const remainingCmd = remaining.map(p => p.name).join(' ');
+
+            this.app.debug(`Could not remove old plugins after ${delays.length} attempts: ${remainingNames}`);
+
+            // Show error with platform-specific commands
+            const isVictronCerbo = configDir === '/data/conf/signalk';
+            const cmdPrefix = isVictronCerbo ? 'On Victron Cerbo GX, ' : '';
+
+            this.app.setPluginError(
+              `${cmdPrefix}Old plugin(s) ${remainingNames} detected. ` +
+              `Manual removal required: cd ${configDir} && npm uninstall ${remainingCmd}`
+            );
             resolve('partial_removal');
           } else {
             this.app.debug('All old plugins eventually removed');

package/lib/TrackLogger.js

@@ -130,7 +130,7 @@ class TrackLogger {
   }
 
   /**
-   * Handle GPS source selection (auto-select or filtered)
+   * Handle GNSS source selection (auto-select or filtered)
    */
   handleSourceSelection(update) {
     if (!this.options.filterSource) {
@@ -142,7 +142,7 @@ class TrackLogger {
       if (!this.autoSelectedSource) {
         this.autoSelectedSource = update.$source;
         this.lastPositionReceived = new Date().getTime();
-        this.app.debug(`Auto-selected GPS source: '${this.autoSelectedSource}'`);
+        this.app.debug(`Auto-selected GNSS source: '${this.autoSelectedSource}'`);
       } else if (update.$source !== this.autoSelectedSource) {
         if (timeSinceLastPosition && timeSinceLastPosition > 300) {
           this.app.debug(`Switching from stale source '${this.autoSelectedSource}' to '${update.$source}' (no data for ${timeSinceLastPosition.toFixed(0)}s)`);
@@ -172,7 +172,7 @@ class TrackLogger {
   isValidPosition(position) {
     // Check if near (0,0) - likely invalid
     if (Math.abs(position.latitude) <= 0.01 && Math.abs(position.longitude) <= 0.01) {
-      this.app.debug('GPS coordinates near (0,0), ignoring point to avoid invalid data logging.');
+      this.app.debug('GNSS coordinates near (0,0), ignoring point to avoid invalid data logging.');
       return false;
     }
     

package/lib/TrackSender.js

@@ -36,44 +36,6 @@ class TrackSender {
     } 
   }
 
-  /**
-   * Test internet connectivity
-   */
-  async testInternet() {
-    const dns = require('dns').promises;
-    
-    this.app.debug('testing internet connection');
-    
-    const timeoutMs = this.options.internetTestTimeout || 2000;
-    this.app.debug(`Using internet test timeout: ${timeoutMs}ms`);
-    
-    const dnsServers = [
-      { name: 'Google DNS', ip: '8.8.8.8' },
-      { name: 'Cloudflare DNS', ip: '1.1.1.1' }
-    ];
-    
-    for (const server of dnsServers) {
-      try {
-        const startTime = Date.now();
-        const result = await Promise.race([
-          dns.reverse(server.ip),
-          new Promise((_, reject) => 
-            setTimeout(() => reject(new Error('DNS timeout')), timeoutMs)
-          )
-        ]);
-        const elapsed = Date.now() - startTime;
-        
-        this.app.debug(`internet connection = true, ${server.name} (${server.ip}) is reachable (took ${elapsed}ms)`);
-        return true;
-      } catch (err) {
-        this.app.debug(`${server.name} (${server.ip}) not reachable:`, err.message);
-      }
-    }
-    
-    this.app.debug(`internet connection = false, no public DNS servers reachable (timeout was ${timeoutMs}ms)`);
-    return false;
-  }
-
   /**
    * Check if track file exists and has content
    */

package/package.json

@@ -3,7 +3,7 @@
   "signalk": {
     "id": "@noforeignland/signalk-to-noforeignland"
   },
-  "version": "1.1.0-beta.2",
+  "version": "1.1.0",
   "description": "SignalK track logger to noforeignland.com",
   "main": "index.js",
   "keywords": [
@@ -24,8 +24,7 @@
     "node": ">=18.0.0"
   },
   "scripts": {
-    "test": "echo \"No tests specified\" && exit 0",
-    "postinstall": "node cleanup-old-plugin.js"
+    "test": "echo \"No tests specified\" && exit 0"
   },
   "dependencies": {
     "cron": "^2.1.0",

package/cleanup-old-plugin.js

@@ -1,80 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Cleanup script for old plugin versions
- * This runs as a standalone script during npm postinstall
- * NOT a class - just a simple executable script
- */
-
-const fs = require('fs');
-const path = require('path');
-
-// Detect SignalK directory (standard ~/.signalk or Victron Cerbo /data/conf/signalk)
-function getSignalKDir() {
-  const victronPath = '/data/conf/signalk';
-  const homePath = path.join(process.env.HOME || '', '.signalk');
-  
-  // Check Victron path first
-  if (fs.existsSync(victronPath)) {
-    return victronPath;
-  }
-  
-  return homePath;
-}
-
-const signalkDir = getSignalKDir();
-console.log(`Using SignalK directory: ${signalkDir}`);
-
-// 1. Migration (only for signalk-to-noforeignland config)
-try {
-  const configPath = path.join(signalkDir, 'plugin-config-data');
-  const oldConfig = path.join(configPath, 'signalk-to-noforeignland.json');
-  const newConfig = path.join(configPath, '@noforeignland-signalk-to-noforeignland.json');
-  
-  if (fs.existsSync(oldConfig) && !fs.existsSync(newConfig)) {
-    fs.copyFileSync(oldConfig, newConfig);
-    fs.copyFileSync(oldConfig, `${oldConfig}.backup`);
-    console.log('✓ Configuration migrated');
-  }
-} catch (e) {
-  console.warn('Could not migrate config:', e.message);
-}
-
-// 2. Uninstall old plugins (with delay so npm can finish)
-setTimeout(() => {
-  try {
-    const oldPlugins = [
-      { dir: path.join(signalkDir, 'node_modules', 'signalk-to-noforeignland'), name: 'signalk-to-noforeignland' },
-      { dir: path.join(signalkDir, 'node_modules', 'signalk-to-nfl'), name: 'signalk-to-nfl' }
-    ];
-    
-    let removedAny = false;
-    const failedPlugins = [];
-    
-    for (const plugin of oldPlugins) {
-      if (fs.existsSync(plugin.dir)) {
-        try {
-          console.log(`Removing old plugin "${plugin.name}"...`);
-          // Direct deletion is safer than npm uninstall during installation
-          fs.rmSync(plugin.dir, { recursive: true, force: true });
-          console.log(`✓ Old plugin "${plugin.name}" removed`);
-          removedAny = true;
-        } catch (e) {
-          console.warn(`Could not remove "${plugin.name}":`, e.message);
-          failedPlugins.push(plugin.name);
-        }
-      }
-    }
-    
-    if (failedPlugins.length > 0) {
-      const uninstallCmd = failedPlugins.join(' ');
-      console.warn(`Please run manually: npm uninstall ${uninstallCmd}`);
-    }
-    
-    if (!removedAny && failedPlugins.length === 0) {
-      console.log('No old plugins found - already clean!');
-    }
-  } catch (e) {
-    console.warn('Error during cleanup:', e.message);
-  }
-}, 2000); // Wait 2 seconds for npm to finish