u2a 3.4.20 → 3.5.1

package/package.json

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

package/src/commands/configure.js

@@ -0,0 +1,125 @@
+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 {
+    if (action === 'status') {
+      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') {
+      setSetting('send_anon_reports', true);
+      logger.info(chalk.green('Anonymous reports have been enabled'));
+    } else if (action === 'disable') {
+      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, reset');
+      return;
+    }
+  } catch (err) {
+    logger.error(`Error configuring reports`, err.message);
+  }
+}
+
+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;
+  }
+
+  switch (category) {
+    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, vcheck, settings');
+      break;
+  }
+}
+
+module.exports = {
+  configure
+};

package/src/index.js

@@ -11,6 +11,7 @@ const { program } = require('commander');
 const { createApp } = require('./commands/create');
 const { listApps } = require('./commands/list');
 const { removeApp } = require('./commands/remove');
+const { configure } = require('./commands/configure');
 const { version } = require('../package.json');
 const { setupConfig } = require('./utils/config');
 const { checkNotRoot } = require('./utils/noroot');
@@ -50,6 +51,13 @@ setupConfig();
     .description('Remove an existing application')
     .action(removeApp);
 
+  program
+  .command('configure [category] [action]')
+  .description('Configure application settings')
+  .action((category, action) => {
+    configure(category, action);
+  });
+
   program.on('command:*', () => {
     console.error(`\nInvalid command: ${program.args.join(' ')}`);
     console.log(`\nUse --help to see the list of available commands.`);

package/src/utils/config.js

@@ -6,6 +6,7 @@ const CONFIG_DIR = path.join(os.homedir(), '.u2a');
 const APPS_DIR = path.join(CONFIG_DIR, 'apps');
 const LOGS_DIR = path.join(CONFIG_DIR, 'logs');
 const DB_PATH = path.join(CONFIG_DIR, 'db.json');
+const SETTINGS_PATH = path.join(CONFIG_DIR, 'settings.json');
 
 function setupConfig() {
   if (!fs.existsSync(CONFIG_DIR)) {
@@ -20,6 +21,9 @@ function setupConfig() {
   if (!fs.existsSync(DB_PATH)) {
     fs.writeFileSync(DB_PATH, JSON.stringify({}, null, 2));
   }
+  if (!fs.existsSync(SETTINGS_PATH)) {
+    fs.writeFileSync(SETTINGS_PATH, JSON.stringify({}, null, 2));
+  }
 }
 
 function readDB() {
@@ -41,6 +45,8 @@ module.exports = {
   CONFIG_DIR,
   APPS_DIR,
   LOGS_DIR,
+  DB_PATH,
+  SETTINGS_PATH,
   setupConfig,
   readDB,
   writeDB,

package/src/utils/logger.js

@@ -3,6 +3,18 @@ const path = require('path');
 const chalk = require('chalk');
 const { LOGS_DIR } = require('./config');
 
+/*
+  To use:
+  const Logger = require('./logger');
+  const logger = new Logger('name');
+
+  //then
+  logger.info('information');
+  logger.warn('warning');
+  logger.error('error message', 'error');
+*/
+
+
 class Logger {
   constructor(component) {
     this.component = component;
@@ -50,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

@@ -0,0 +1,120 @@
+const fs = require('fs');
+const path = require('path');
+const axios = require('axios');
+const Logger = require('./logger');
+const { setupConfig, CONFIG_DIR } = require('./config');
+const { initSettings, getSetting } = require('./settings');
+
+setupConfig(); // builds ~/.u2a/*
+
+const logger = new Logger('postinstall');
+const postinstallJsonPath = path.join(CONFIG_DIR, 'postinstall.json');
+let isUpgrade = false;
+let currentVersion = '0.0.0'; //0.0.0 for new installations
+let sendAnonReports = true; // u2a configure reports disable to disable
+
+const formatVersionLine = (label, version) => {
+    // calculates how many spaces we need after the version to have a correct formatting
+    const baseLength = `; ${label}: `.length + version.length;
+    const spaceCount = Math.max(0, 30 - baseLength);
+    const spaces = ' '.repeat(spaceCount);
+    
+    return `; ${label}: ${version}${spaces};`;
+};
+
+async function run() {
+    //check if postinstall.json exists (exists -> update, doesnt -> new install)
+    if (fs.existsSync(postinstallJsonPath)) {
+        try {
+            const postinstallData = JSON.parse(fs.readFileSync(postinstallJsonPath, 'utf8'));
+            currentVersion = postinstallData.version || '';
+            isUpgrade = true;
+            
+            let newVersion = '';
+            try {
+                const packageJsonPath = path.join(__dirname, '..', '..', 'package.json');
+                const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+                newVersion = packageJson.version || '';
+            } catch (err) {
+                logger.error(`Error reading package.json for display`, err.message);
+                newVersion = 'unknown';
+            }
+            
+            logger.info(';=============================;');
+            logger.info('; u2a has been updated!       ;');
+            logger.info('; Successfully migrated from  ;');
+            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;
+        }
+    }
+
+    const sendAnonReports = getSetting('send_anon_reports');
+
+    // shows this cool message if it isnt an upgrade
+    if (!isUpgrade) {
+        logger.info(';=============================;');
+        logger.info('; Welcome to u2a !            ;');
+        logger.info('; Thanks for downloading this ;');
+        logger.info('; tool !                      ;');
+        logger.info(';                             ;');
+        logger.info('; Create a local webapp with  ;');
+        logger.info('; \'u2a create <url/domain>\'   ;');
+        logger.info(';                             ;');
+        logger.info('; Check docs.urltoapp.xyz for ;');
+        logger.info('; more detailed usage.        ;');
+        logger.info(';                             ;');
+        logger.info('; Note: Anonymous installs    ;');
+        logger.info('; reports are enabled by      ;');
+        logger.info('; default. To disable:        ;');
+        logger.info('; \'u2a configure reports      ;');
+        logger.info('; disable\'                    ;');
+        logger.info(';=============================;');
+        
+        initSettings(true);
+    }
+
+    const packageJsonPath = path.join(__dirname, '..', '..', 'package.json');
+    let newVersion = '';
+    
+    try {
+        const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+        newVersion = packageJson.version || '';
+    } catch (err) {
+        logger.error(`Error reading package.json`, err.message);
+    }
+
+    if (sendAnonReports) {
+        try {
+
+            const params = new URLSearchParams({
+                previousVersion: currentVersion,
+                newVersion: newVersion
+            });
+
+            // backend here https://github.com/url2app/urltoapp.xyz/blob/main/api/v1/api/reports.php
+            await axios.get(`https://urltoapp.xyz/api/v1/reports?${params.toString()}`);
+            logger.debug('Anonymous usage report sent');
+        } catch (err) {
+            logger.debug(`Failed to send anonymous report: ${err.message}`);
+        }
+    }
+
+    try {
+        fs.writeFileSync(postinstallJsonPath, JSON.stringify({
+            version: newVersion,
+            installed_at: new Date().toISOString()
+        }, null, 2));
+    } catch (err) {
+        logger.error(`Error updating postinstall.json`, err.message);
+    }
+}
+
+run().catch(err => {
+    logger.error(`Unexpected error`, err.message);
+});

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],