@noforeignland/signalk-to-noforeignland 1.0.1-beta.8 → 1.1.0-beta.11

package/lib/ConfigManager.js

@@ -0,0 +1,216 @@
+const path = require('path');
+
+const defaultTracksDir = 'nfl-track';
+
+class ConfigManager {
+  constructor(app) {
+    this.app = app;
+  }
+
+  /**
+   * Migrate old flat config structure to new grouped structure
+   */
+  async migrateOldConfig(options) {
+    if (options.boatApiKey && !options.mandatory) {
+      this.app.debug('Migrating old configuration to new grouped structure');
+      
+      const migratedOptions = {
+        mandatory: {
+          boatApiKey: options.boatApiKey
+        },
+        advanced: {
+          minMove: options.minMove !== undefined ? options.minMove : 50,
+          minSpeed: options.minSpeed !== undefined ? options.minSpeed : 1.5,
+          sendWhileMoving: options.sendWhileMoving !== undefined ? options.sendWhileMoving : true,
+          ping_api_every_24h: options.ping_api_every_24h !== undefined ? options.ping_api_every_24h : true
+        },
+        expert: {
+          filterSource: options.filterSource,
+          trackDir: options.trackDir,
+          keepFiles: options.keepFiles !== undefined ? options.keepFiles : false,
+          trackFrequency: options.trackFrequency !== undefined ? options.trackFrequency : 60,
+          internetTestTimeout: options.internetTestTimeout !== undefined ? options.internetTestTimeout : 2000,
+          apiCron: options.apiCron || '*/10 * * * *',
+          apiTimeout: options.apiTimeout !== undefined ? options.apiTimeout : 30
+        }
+      };
+      
+      try {
+        this.app.debug('Saving migrated configuration...');
+        await this.app.savePluginOptions(migratedOptions, () => {
+          this.app.debug('Configuration successfully migrated and saved');
+        });
+        return { options: migratedOptions, migrated: true };
+      } catch (err) {
+        this.app.debug('Failed to save migrated configuration:', err.message);
+        return { options: migratedOptions, migrated: true };
+      }
+    }
+    
+    return { options, migrated: false };
+  }
+
+  /**
+   * Flatten nested config structure and apply defaults
+   */
+  flattenConfig(options) {
+    return {
+      boatApiKey: options.mandatory?.boatApiKey,
+      minMove: options.advanced?.minMove !== undefined ? options.advanced.minMove : 80,
+      minSpeed: options.advanced?.minSpeed !== undefined ? options.advanced.minSpeed : 1.5,
+      sendWhileMoving: options.advanced?.sendWhileMoving !== undefined ? options.advanced.sendWhileMoving : true,
+      ping_api_every_24h: options.advanced?.ping_api_every_24h !== undefined ? options.advanced.ping_api_every_24h : true,
+      filterSource: options.expert?.filterSource,
+      trackDir: options.expert?.trackDir || defaultTracksDir,
+      keepFiles: options.expert?.keepFiles !== undefined ? options.expert.keepFiles : false,
+      trackFrequency: options.expert?.trackFrequency !== undefined ? options.expert.trackFrequency : 60,
+      internetTestTimeout: options.expert?.internetTestTimeout !== undefined ? options.expert.internetTestTimeout : 2000,
+      apiCron: options.expert?.apiCron || '*/10 * * * *',
+      apiTimeout: options.expert?.apiTimeout !== undefined ? options.expert.apiTimeout : 30
+    };
+  }
+
+  /**
+   * Validate boat API key
+   */
+  validateApiKey(config) {
+    if (!config.boatApiKey || config.boatApiKey.trim() === '') {
+      throw new Error(
+        'No boat API key configured. Please set your API key in plugin settings ' +
+        '(Mandatory Settings > Boat API key). You can find your API key at ' +
+        'noforeignland.com under Account > Settings > Boat tracking > API Key.'
+      );
+    }
+  }
+
+  /**
+   * Resolve track directory path (absolute or relative to data dir)
+   */
+  resolveTrackDir(config, dataDirPath) {
+    if (!path.isAbsolute(config.trackDir)) {
+      return path.join(dataDirPath, config.trackDir);
+    }
+    return config.trackDir;
+  }
+
+  /**
+   * Randomize CRON schedule to avoid all instances running at same time
+   */
+  randomizeCron(config) {
+    if (!config.apiCron || config.apiCron === '*/10 * * * *') {
+      const startMinute = Math.floor(Math.random() * 10);
+      const startSecond = Math.floor(Math.random() * 60);
+      config.apiCron = `${startSecond} ${startMinute}/10 * * * *`;
+    }
+    return config;
+  }
+
+  /**
+   * Get the full schema for plugin configuration
+   */
+  static getSchema(pluginName) {
+    return {
+      title: pluginName,
+      description: 'Some parameters need for use',
+      type: 'object',
+      properties: {
+        // Mandatory Settings Group
+        mandatory: {
+          type: 'object',
+          title: 'Mandatory Settings',
+          properties: {
+            boatApiKey: {
+              type: 'string',
+              title: 'Boat API Key',
+              description: 'Boat API Key from noforeignland.com. Can be found in Account > Settings > Boat tracking > API Key.'
+            }
+          }
+        },
+        
+        // Advanced Settings Group
+        advanced: {
+          type: 'object',
+          title: 'Advanced Settings',
+          properties: {
+            minMove: {
+              type: 'number',
+              title: 'Minimum boat move to log in meters',
+              description: 'To keep file sizes small we only log positions if a move larger than this size (if set to 0 will log every move)',
+              default: 80
+            },
+            minSpeed: {
+              type: 'number',
+              title: 'Minimum boat speed to log in knots',
+              description: 'To keep file sizes small we only log positions if boat speed goes above this value to minimize recording position on anchor or mooring (if set to 0 will log every move)',
+              default: 1.5
+            },
+            sendWhileMoving: {
+              type: 'boolean',
+              title: 'Attempt sending location while moving',
+              description: 'Should the plugin attempt to send tracking data to NFL while detecting the vessel is moving or only when stopped?',
+              default: true
+            },
+            ping_api_every_24h: {
+              type: 'boolean',
+              title: 'Force a send every 24 hours',
+              description: 'Keeps your boat active on NFL in your current location even if you do not move',
+              default: true
+            }
+          }
+        },
+        
+        // Expert Settings Group
+        expert: {
+          type: 'object',
+          title: 'Expert Settings',
+          properties: {
+            filterSource: {
+              type: 'string',
+              title: 'Position source device',
+              description: 'EMPTY DEFAULT IS FINE - Set this value to the name of a source if you want to only use the position given by that source.'
+            },
+            trackDir: {
+              type: 'string',
+              title: 'Directory to cache tracks',
+              description: 'EMPTY DEFAULT IS FINE - Path to store track data. Relative paths are stored in plugin data directory. Absolute paths can point anywhere.\nDefault: nfl-track'
+            },
+            keepFiles: {
+              type: 'boolean',
+              title: 'Keep track files on disk',
+              description: 'If you have a lot of hard drive space you can keep the track files for logging purposes.',
+              default: false
+            },
+            trackFrequency: {
+              type: 'integer',
+              title: 'Position tracking frequency in seconds',
+              description: 'To keep file sizes small we only log positions once in a while (unless you set this value to 0)',
+              default: 60
+            },
+            apiCron: {
+              type: 'string',
+              title: 'Send attempt CRON',
+              description: 'We send the tracking data to NFL once in a while, you can set the schedule with this setting.\nCRON format: https://crontab.guru/',
+              default: '*/10 * * * *'
+            },
+            internetTestTimeout: {
+              type: 'number',
+              title: 'Timeout for testing internet connection in ms',
+              description: 'Set this number higher for slower computers and internet connections',
+              default: 2000
+            },
+            apiTimeout: {
+              type: 'integer',
+              title: 'API request timeout in seconds',
+              description: 'Timeout for sending data to NFL API. Increase for slow connections.',
+              default: 30,
+              minimum: 10,
+              maximum: 180
+            }
+          }
+        }
+      }
+    };
+  }
+}
+
+module.exports = ConfigManager;

package/lib/DataPathEmitter.js

@@ -0,0 +1,93 @@
+class DataPathEmitter {
+  constructor(app, pluginId) {
+    this.app = app;
+    this.pluginId = pluginId;
+    this.currentError = null;
+  }
+
+  /**
+   * Emit SignalK delta for a data path
+   */
+  emitDelta(path, value) {
+    try {
+      const delta = {
+        context: 'vessels.self',
+        updates: [{
+          timestamp: new Date().toISOString(),
+          values: [{
+            path: path,
+            value: value
+          }]
+        }]
+      };
+      this.app.handleMessage(this.pluginId, delta);
+    } catch (err) {
+      this.app.debug(`Failed to emit delta for ${path}:`, err.message);
+    }
+  }
+
+  /**
+   * Update status paths with current state
+   */
+  updateStatusPaths(options, lastPosition, lastSuccessfulTransfer, autoSelectedSource) {
+    const hasError = this.currentError !== null;
+  
+    if (!hasError) {
+      const activeSource = options.filterSource || autoSelectedSource || '';
+      const saveTime = lastPosition 
+        ? new Date(lastPosition.currentTime).toLocaleTimeString() 
+        : 'None since start';
+      const transferTime = lastSuccessfulTransfer 
+        ? lastSuccessfulTransfer.toLocaleTimeString() 
+        : 'None since start';
+      const shortStatus = `Save: ${saveTime} | Transfer: ${transferTime}`;
+      
+      this.emitDelta('noforeignland.status', shortStatus);
+      this.emitDelta('noforeignland.source', activeSource);
+    } else {
+      this.emitDelta('noforeignland.status', `ERROR: ${this.currentError}`);
+    }
+    
+    this.emitDelta('noforeignland.status_boolean', hasError ? 1 : 0);
+  }
+
+  /**
+   * Emit savepoint deltas
+   */
+  emitSavepoint() {
+    const now = new Date();
+    this.emitDelta('noforeignland.savepoint', now.toISOString());
+    this.emitDelta('noforeignland.savepoint_local', now.toLocaleString());
+  }
+
+  /**
+   * Emit API transfer deltas
+   */
+  emitApiTransfer(transferTime) {
+    this.emitDelta('noforeignland.sent_to_api', transferTime.toISOString());
+    this.emitDelta('noforeignland.sent_to_api_local', transferTime.toLocaleString());
+  }
+
+  /**
+   * Set error state
+   */
+  setError(error) {
+    this.currentError = error;
+  }
+
+  /**
+   * Clear error state
+   */
+  clearError() {
+    this.currentError = null;
+  }
+
+  /**
+   * Get current error
+   */
+  getError() {
+    return this.currentError;
+  }
+}
+
+module.exports = DataPathEmitter;

package/lib/DirectoryUtils.js

@@ -0,0 +1,38 @@
+const fs = require('fs');
+
+class DirectoryUtils {
+  /**
+   * Create directory with proper error handling
+   */
+  static createDir(dir, app) {
+    if (fs.existsSync(dir)) {
+      try {
+        fs.accessSync(dir, fs.constants.R_OK | fs.constants.W_OK);
+        return true;
+      } catch (error) {
+        app.debug('[createDir]', error.message);
+        throw new Error(`No rights to directory ${dir}`);
+      }
+    } else {
+      try {
+        fs.mkdirSync(dir, { recursive: true });
+        return true;
+      } catch (error) {
+        switch (error.code) {
+          case 'EACCES':
+          case 'EPERM':
+            app.debug(`Failed to create ${dir} by Permission denied`);
+            throw new Error(`Failed to create ${dir} by Permission denied`);
+          case 'ETIMEDOUT':
+            app.debug(`Failed to create ${dir} by Operation timed out`);
+            throw new Error(`Failed to create ${dir} by Operation timed out`);
+          default:
+            app.debug(`Error creating directory ${dir}: ${error.message}`);
+            throw new Error(`Error creating directory ${dir}: ${error.message}`);
+        }
+      }
+    }
+  }
+}
+
+module.exports = DirectoryUtils;

package/lib/HealthMonitor.js

@@ -0,0 +1,91 @@
+class HealthMonitor {
+  constructor(app, options) {
+    this.app = app;
+    this.options = options;
+    this.checkInterval = null;
+  }
+
+  /**
+   * Start position health monitoring
+   */
+  start(getLastPositionReceived, getAutoSelectedSource, onError, onHealthy) {
+    // Periodic health check every 5 minutes
+    this.checkInterval = setInterval(() => {
+      this.performHealthCheck(
+        getLastPositionReceived(),
+        getAutoSelectedSource(),
+        onError,
+        onHealthy
+      );
+    }, 5 * 60 * 1000);
+    
+    // Initial check after 2 minutes of startup
+    setTimeout(() => {
+      this.performInitialCheck(
+        getLastPositionReceived(),
+        getAutoSelectedSource(),
+        onError
+      );
+    }, 2 * 60 * 1000);
+  }
+
+  /**
+   * Perform periodic health check
+   */
+  performHealthCheck(lastPositionReceived, autoSelectedSource, onError, onHealthy) {
+    const now = new Date().getTime();
+    const timeSinceLastPosition = lastPositionReceived 
+      ? (now - lastPositionReceived) / 1000 
+      : null;
+    
+    const activeSource = this.options.filterSource || autoSelectedSource || 'any';
+    const filterMsg = activeSource !== 'any' ? ` from source '${activeSource}'` : '';
+    
+    if (!lastPositionReceived) {
+      const errorMsg = this.options.filterSource
+        ? `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 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);
+    } else {
+      this.app.debug(`Position health check: OK (last position ${timeSinceLastPosition.toFixed(0)} seconds ago${filterMsg})`);
+      onHealthy();
+    }
+  }
+
+  /**
+   * Perform initial health check after startup
+   */
+  performInitialCheck(lastPositionReceived, autoSelectedSource, onError) {
+    if (!lastPositionReceived) {
+      const activeSource = this.options.filterSource || autoSelectedSource || 'any';
+      const errorMsg = this.options.filterSource
+        ? `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' + 
+        (activeSource !== 'any' ? ` from source '${activeSource}'` : ''));
+    }
+  }
+
+  /**
+   * Stop health monitoring
+   */
+  stop() {
+    if (this.checkInterval) {
+      clearInterval(this.checkInterval);
+      this.checkInterval = null;
+    }
+  }
+}
+
+module.exports = HealthMonitor;

package/lib/PluginCleanup.js

@@ -0,0 +1,259 @@
+const fs = require('fs-extra');
+const path = require('path');
+
+class PluginCleanup {
+  constructor(app) {
+    this.app = app;
+  }
+
+  /**
+   * Cleanup old plugin versions (signalk-to-noforeignland and signalk-to-nfl)
+   */
+  async cleanup() {
+    try {
+      // Detect SignalK directory (standard or Victron Cerbo)
+      const victronPath = '/data/conf/signalk';
+      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. 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 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 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');
+    }
+  }
+
+  /**
+   * Remove old plugin directories - with immediate and delayed attempts
+   */
+  async removeOldPlugins(configDir) {
+    const oldPlugins = [
+      { dir: path.join(configDir, 'node_modules', 'signalk-to-noforeignland'), name: 'signalk-to-noforeignland' },
+      { dir: path.join(configDir, 'node_modules', 'signalk-to-nfl'), name: 'signalk-to-nfl' }
+    ];
+    
+    const foundOldPlugins = oldPlugins.filter(plugin => fs.existsSync(plugin.dir));
+    
+    if (foundOldPlugins.length === 0) {
+      return null;
+    }
+
+    const pluginNames = foundOldPlugins.map(p => `"${p.name}"`).join(' and ');
+    const uninstallCmd = foundOldPlugins.map(p => p.name).join(' ');
+    
+    this.app.debug(`Old plugin(s) detected: ${pluginNames}`);
+    
+    // Immediate removal attempt
+    let anyRemovedNow = false;
+    const stillPresent = [];
+    
+    for (const plugin of foundOldPlugins) {
+      try {
+        this.app.debug(`Attempting immediate removal of: ${plugin.name}...`);
+        await fs.remove(plugin.dir);
+        this.app.debug(`✓ Old plugin "${plugin.name}" removed immediately`);
+        anyRemovedNow = true;
+      } catch (err) {
+        this.app.debug(`Could not remove "${plugin.name}" immediately:`, err.message);
+        stillPresent.push(plugin);
+      }
+    }
+    
+    if (stillPresent.length === 0) {
+      this.app.debug('All old plugins removed successfully');
+      return 'all_removed';
+    }
+
+    // Don't show error immediately - log that we're retrying
+    const stillPresentNames = stillPresent.map(p => `"${p.name}"`).join(' and ');
+    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
+      let attemptIndex = 0;
+      
+      const attemptRemoval = async () => {
+        if (attemptIndex >= delays.length) {
+          // 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(' 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');
+            resolve('all_removed');
+          }
+          return;
+        }
+        
+        const delay = delays[attemptIndex];
+        attemptIndex++;
+        
+        setTimeout(async () => {
+          this.app.debug(`Delayed removal attempt ${attemptIndex}/${delays.length}...`);
+          
+          const remaining = [];
+          for (const plugin of stillPresent) {
+            if (!fs.existsSync(plugin.dir)) {
+              this.app.debug(`Plugin "${plugin.name}" already removed`);
+              continue;
+            }
+            
+            try {
+              await fs.remove(plugin.dir);
+              this.app.debug(`✓ Old plugin "${plugin.name}" removed on attempt ${attemptIndex}`);
+            } catch (err) {
+              this.app.debug(`Still cannot remove "${plugin.name}":`, err.message);
+              remaining.push(plugin);
+            }
+          }
+          
+          if (remaining.length === 0) {
+            this.app.debug('All old plugins successfully removed');
+            // Clear the error
+            this.app.setPluginStatus('Started (old plugins cleaned up)');
+            resolve('all_removed');
+          } else {
+            stillPresent.length = 0;
+            stillPresent.push(...remaining);
+            attemptRemoval(); // Next attempt
+          }
+        }, delay);
+      };
+      
+      attemptRemoval();
+    });
+  }
+}
+
+module.exports = PluginCleanup;