u2a 3.5.0 → 3.5.1

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "u2a",
-    "version": "3.5.0",
+    "version": "3.5.1",
     "description": "URL to App - Turn any URL into a desktop application",
     "main": "src/index.js",
     "bin": {
@@ -8,6 +8,7 @@
     },
     "scripts": {
         "start": "node src/index.js",
+        "debug": "set DEBUG=1 && node src/index.js",
         "postinstall": "node src/utils/postinstall.js"
     },
     "keywords": [

package/src/commands/configure.js

@@ -1,49 +1,105 @@
-const fs = require('fs');
-const { SETTINGS_PATH } = require('../utils/config');
 const Logger = require('../utils/logger');
 const chalk = require('chalk');
+const { initSettings, getSetting, setSetting, resetSetting, DEFAULT_SETTINGS } = require('../utils/settings');
+const inquirer = require('inquirer');
 
 const logger = new Logger('configure');
 
 function configureReports(action) {
   try {
-    let settings = {};
-    if (fs.existsSync(SETTINGS_PATH)) {
-      settings = JSON.parse(fs.readFileSync(SETTINGS_PATH, 'utf8'));
-    }
-
     if (action === 'status') {
-      const status = settings.send_anon_reports !== false;
+      const status = getSetting('send_anon_reports');
       logger.info(`Anonymous reports are currently ${status ? chalk.green('enabled') : chalk.yellow('disabled')}`);
+      logger.info(`Default setting is: ${DEFAULT_SETTINGS.send_anon_reports ? chalk.green('enabled') : chalk.yellow('disabled')}`);
       return;
     } else if (action === 'enable') {
-      settings.send_anon_reports = true;
+      setSetting('send_anon_reports', true);
       logger.info(chalk.green('Anonymous reports have been enabled'));
     } else if (action === 'disable') {
-      settings.send_anon_reports = false;
+      setSetting('send_anon_reports', false);
       logger.info(chalk.yellow('Anonymous reports have been disabled'));
+    } else if (action === 'reset') {
+      resetSetting('send_anon_reports');
+      logger.info(`Anonymous reports have been resetted to: ${DEFAULT_SETTINGS.send_anon_reports ? chalk.green('enabled') : chalk.yellow('disabled')}`);
     } else {
       logger.error(`Invalid action: ${action}`);
-      logger.info('Available actions: status, enable, disable');
+      logger.info('Available actions: status, enable, disable, reset');
       return;
     }
-
-    fs.writeFileSync(SETTINGS_PATH, JSON.stringify(settings, null, 2));
   } catch (err) {
     logger.error(`Error configuring reports`, err.message);
   }
 }
 
-function configure(category, action) {
+function configureVersionCheck(action) {
+  try {
+    if (action === 'status') {
+      const status = getSetting('version_check');
+      logger.info(`Version check is currently ${status ? chalk.green('enabled') : chalk.yellow('disabled')}`);
+      logger.info(`Default setting is: ${DEFAULT_SETTINGS.version_check ? chalk.green('enabled') : chalk.yellow('disabled')}`);
+      return;
+    } else if (action === 'enable') {
+      setSetting('version_check', true);
+      logger.info(chalk.green('Version check has been enabled'));
+    } else if (action === 'disable') {
+      setSetting('version_check', false);
+      logger.info(chalk.yellow('Version check has been disabled'));
+    } else if (action === 'reset') {
+      resetSetting('version_check');
+      logger.info(`Version check has been resetted to: ${DEFAULT_SETTINGS.send_anon_reports ? chalk.green('enabled') : chalk.yellow('disabled')}`);
+    } else {
+      logger.error(`Invalid action: ${action}`);
+      logger.info('Available actions: status, enable, disable, reset');
+      return;
+    }
+  } catch (err) {
+    logger.error(`Error configuring version check`, err.message);
+  }
+}
+
+async function resetSettings(action) {
+  try {
+    if (action === 'reset') {
+      const answer = await inquirer.prompt([
+        {
+          type: 'confirm',
+          name: 'confirm',
+          message: `Are you sure you want to reset all settings to default?`,
+          default: false
+        }
+      ]);
+
+      if (!answer.confirm) {
+        logger.info('Operation canceled');
+        return;
+      }
+
+      initSettings(true);
+      logger.info(chalk.green('All settings have been reset'));
+      return;
+    } else {
+      logger.error(`Invalid action: ${action}`);
+      logger.info('Available actions: reset');
+      return;
+    }
+  } catch (err) {
+    logger.error(`Error resetting settings`, err.message);
+  }
+}
+
+async function configure(category, action) {
   if (!category || !action) {
     logger.error('Missing category or action');
     logger.info('Usage: u2a configure [category] [action]');
     logger.info('Available categories:');
     logger.info('  reports - Configure anonymous usage reports');
+    logger.info('  settings - Resets settings (only reset action)');
+    logger.info('  vcheck - Configure automatic version check');
     logger.info('Available actions:');
     logger.info('  status  - Check current status');
     logger.info('  enable  - Enable specified category');
     logger.info('  disable - Disable specified category');
+    logger.info('  reset - Resets specified category to default');
     return;
   }
 
@@ -51,9 +107,15 @@ function configure(category, action) {
     case 'reports':
       configureReports(action);
       break;
+    case 'vcheck':
+      configureVersionCheck(action);
+      break;
+    case 'settings':
+      await resetSettings(action);
+      break;
     default:
       logger.error(`Unknown configuration category: ${category}`);
-      logger.info('Available categories: reports');
+      logger.info('Available categories: reports, vcheck, settings');
       break;
   }
 }

package/src/utils/logger.js

@@ -62,8 +62,10 @@ class Logger {
     }
   }
 
-  debug(message) {
-    const formattedMessage = this._format('DEBUG', message);
+  debug(message, msg2 = '') {
+    // i added msg2 cuz some parts of the code are using it, idk why
+    const formattedMessage = this._format('DEBUG', `${message}${msg2 ? ' ' + msg2 : ''}`);
+
     if (process.env.DEBUG) {
       console.log(chalk.gray(formattedMessage));
     }

package/src/utils/postinstall.js

@@ -2,7 +2,8 @@ const fs = require('fs');
 const path = require('path');
 const axios = require('axios');
 const Logger = require('./logger');
-const { setupConfig, CONFIG_DIR, SETTINGS_PATH } = require('./config');
+const { setupConfig, CONFIG_DIR } = require('./config');
+const { initSettings, getSetting } = require('./settings');
 
 setupConfig(); // builds ~/.u2a/*
 
@@ -45,21 +46,15 @@ async function run() {
             logger.info(formatVersionLine('Old version', currentVersion));
             logger.info(formatVersionLine('New version', newVersion));
             logger.info(';=============================;');
+
+            initSettings();
         } catch (err) {
             logger.error(`Error reading postinstall.json`, err.message);
             isUpgrade = false;
         }
     }
 
-    if (fs.existsSync(SETTINGS_PATH)) {
-        try {
-            const settingsData = JSON.parse(fs.readFileSync(SETTINGS_PATH, 'utf8'));
-            sendAnonReports = settingsData.send_anon_reports !== false;
-        } catch (err) {
-            logger.error(`Error reading settings.json`, err.message);
-            sendAnonReports = true;
-        }
-    }
+    const sendAnonReports = getSetting('send_anon_reports');
 
     // shows this cool message if it isnt an upgrade
     if (!isUpgrade) {
@@ -81,8 +76,7 @@ async function run() {
         logger.info('; disable\'                    ;');
         logger.info(';=============================;');
         
-        const settings = { send_anon_reports: true };
-        fs.writeFileSync(SETTINGS_PATH, JSON.stringify(settings, null, 2));
+        initSettings(true);
     }
 
     const packageJsonPath = path.join(__dirname, '..', '..', 'package.json');

package/src/utils/settings.js

@@ -0,0 +1,111 @@
+const fs = require('fs');
+const { SETTINGS_PATH } = require('./config');
+const Logger = require('./logger');
+
+const logger = new Logger('settings');
+
+const DEFAULT_SETTINGS = {
+    send_anon_reports: true,
+    version_check: true
+};
+
+// reset is DANGEROUS ! resets all settings
+function initSettings(reset = false) {
+    try {
+        let currentSettings = {};
+
+        if (!reset && fs.existsSync(SETTINGS_PATH)) {
+            try {
+                currentSettings = JSON.parse(fs.readFileSync(SETTINGS_PATH, 'utf8'));
+                logger.debug('Existing settings loaded');
+            } catch (err) {
+                logger.debug(`Error reading existing settings.json, will reinitialize`, err.message);
+                currentSettings = {};
+            }
+        }
+
+        if (reset) {
+            logger.debug('Resetting all settings to default values');
+            fs.writeFileSync(SETTINGS_PATH, JSON.stringify({ ...DEFAULT_SETTINGS }, null, 2));
+            return { ...DEFAULT_SETTINGS };
+        }
+
+        const mergedSettings = {};
+
+        Object.keys(DEFAULT_SETTINGS).forEach(key => {
+            mergedSettings[key] = currentSettings[key] !== undefined
+                ? currentSettings[key]
+                : DEFAULT_SETTINGS[key];
+        });
+
+        Object.keys(currentSettings).forEach(key => {
+            if (mergedSettings[key] === undefined) {
+                mergedSettings[key] = currentSettings[key];
+            }
+        });
+
+        fs.writeFileSync(SETTINGS_PATH, JSON.stringify(mergedSettings, null, 2));
+        logger.debug('Settings initialized successfully');
+
+        return mergedSettings;
+    } catch (err) {
+        logger.debug(`Error initializing settings.json`, err.message);
+        return { ...DEFAULT_SETTINGS };
+    }
+}
+
+function getSettings() {
+    try {
+        if (fs.existsSync(SETTINGS_PATH)) {
+            return JSON.parse(fs.readFileSync(SETTINGS_PATH, 'utf8'));
+        }
+        return {};
+    } catch (err) {
+        logger.debug(`Error reading settings.json`, err.message);
+        return {};
+    }
+}
+
+
+function saveSettings(settings) {
+    try {
+        fs.writeFileSync(SETTINGS_PATH, JSON.stringify(settings, null, 2));
+        logger.debug('Settings saved successfully');
+    } catch (err) {
+        logger.debug(`Error writing settings.json`, err.message);
+    }
+}
+
+
+function getSetting(key, defaultValue = null) {
+    const settings = getSettings();
+    return settings[key] !== undefined ? settings[key] : defaultValue;
+}
+//use : setSetting('version_check', true);
+function setSetting(key, value) {
+    const settings = getSettings();
+    settings[key] = value;
+    saveSettings(settings);
+}
+
+function resetSetting(key) {
+    if (!(key in DEFAULT_SETTINGS)) {
+        logger.debug(`resetSetting: "${key}" is not a valid default setting key`);
+        return;
+    }
+
+    const settings = getSettings();
+    settings[key] = DEFAULT_SETTINGS[key];
+    saveSettings(settings);
+    logger.debug(`Setting "${key}" reset to default value`);
+}
+
+
+module.exports = {
+    initSettings,
+    getSettings,
+    saveSettings,
+    getSetting,
+    setSetting,
+    resetSetting
+};

package/src/utils/versionCheck.js

@@ -1,6 +1,7 @@
 const axios = require('axios');
 const { version } = require('../../package.json');
 const Logger = require('./logger');
+const { getSetting } = require('./settings');
 
 const logger = new Logger('version-check');
 
@@ -12,7 +13,23 @@ const UPDATE_TYPES = {
   FEATURE: 'feature'
 };
 
-async function checkVersion(silent = false) {
+async function checkVersion(silent = false, forceCheck = false) {
+  //check if version check is enabled in settings
+  const versionCheckEnabled = getSetting('version_check');
+
+  //if version check is disabled and not forcing skip the check (btw idk why i made forcecheck)
+  if (!versionCheckEnabled && !forceCheck) {
+    logger.debug('Version check is disabled in settings');
+    return {
+      current: version,
+      latest: null,
+      needsUpdate: false,
+      updateType: UPDATE_TYPES.NONE,
+      skipped: true,
+      reason: 'version_check disabled in settings'
+    };
+  }
+
   try {
     logger.debug('Started version check');
     const response = await axios.get('https://urltoapp.xyz/api/v1/getlastest', {
@@ -21,7 +38,7 @@ async function checkVersion(silent = false) {
 
     const latestVersion = response.data.trim();
     logger.debug(`Version retrieved: ${latestVersion}`);
-    
+
     const versionComparison = compareVersions(version, latestVersion);
     const updateType = getUpdateType(version, latestVersion);
     const needsUpdate = versionComparison < 0;
@@ -29,22 +46,22 @@ async function checkVersion(silent = false) {
     if (!silent && needsUpdate) {
       logger.debug(`New update available: ${latestVersion} (${updateType})`);
       console.log('');
-      
+
       const updateMessages = {
         [UPDATE_TYPES.SECURITY]: `CRITICAL: Security update (${latestVersion}) available!`,
         [UPDATE_TYPES.CORE]: `IMPORTANT: Core update (${latestVersion}) available!`,
         [UPDATE_TYPES.FEATURE]: `NEW: Feature update (${latestVersion}) available!`
       };
-      
+
       if (updateType === UPDATE_TYPES.SECURITY) {
         logger.error(updateMessages[UPDATE_TYPES.SECURITY]); //using .error cuz im lazy to do other variations, sorry ! :)
       } else {
         logger.warn(updateMessages[updateType] || `A new update (${latestVersion}) is available!`);
       }
-      
+
       logger.warn(`Current version: ${version}`);
       logger.warn(`Update u2a with: npm install -g u2a@${latestVersion}`);
-      
+
       if (updateType === UPDATE_TYPES.SECURITY) {
         logger.error('This update fixes SECURITY VULNERABILITIES and should be installed immediately!');
       }
@@ -55,15 +72,18 @@ async function checkVersion(silent = false) {
       latest: latestVersion,
       needsUpdate,
       updateType,
-      updateDetails: needsUpdate ? getUpdateDetails(version, latestVersion) : null
+      updateDetails: needsUpdate ? getUpdateDetails(version, latestVersion) : null,
+      skipped: false
     };
   } catch (error) {
+    logger.debug(`Version check failed: ${error.message}`);
     return {
       current: version,
       latest: null,
       needsUpdate: false,
       updateType: UPDATE_TYPES.NONE,
-      error: error.message
+      error: error.message,
+      skipped: false
     };
   }
 }
@@ -71,15 +91,15 @@ async function checkVersion(silent = false) {
 function compareVersions(v1, v2) {
   const parts1 = v1.split('.').map(Number);
   const parts2 = v2.split('.').map(Number);
-  
+
   for (let i = 0; i < Math.max(parts1.length, parts2.length); i++) {
     const part1 = parts1[i] || 0;
     const part2 = parts2[i] || 0;
-    
+
     if (part1 < part2) return -1;
     if (part1 > part2) return 1;
   }
-  
+
   return 0;
 }
 
@@ -87,10 +107,10 @@ function getUpdateType(currentVersion, latestVersion) {
   if (currentVersion === latestVersion) {
     return UPDATE_TYPES.NONE;
   }
-  
+
   const current = currentVersion.split('.').map(Number);
   const latest = latestVersion.split('.').map(Number);
-  
+
   /*
     a.b.c format where:
     a: security version
@@ -106,15 +126,14 @@ function getUpdateType(currentVersion, latestVersion) {
   } else if (latest[2] > current[2]) {
     return UPDATE_TYPES.FEATURE;
   }
-  
+
   return UPDATE_TYPES.NONE; //current is newer or same
 }
 
-
 function getUpdateDetails(currentVersion, latestVersion) {
   const current = currentVersion.split('.').map(Number);
   const latest = latestVersion.split('.').map(Number);
-  
+
   return {
     securityChanges: latest[0] - current[0],
     coreChanges: latest[1] - current[1],