u2a 2.1.8 → 3.0.0

package/README.md

@@ -1,5 +1,5 @@
 <div align="center">
-  <a href="#" style="display: block; text-align: center;">
+  <a href="https://urltoapp.xyz" style="display: block; text-align: center;">
     <img
       alt="Image of this repo"
       src="https://togp.xyz?owner=douxxtech&repo=urltoapp&theme=json-dark-all&cache=false"
@@ -86,8 +86,37 @@ This will:
 2. Delete the application files
 3. Remove the entry from the U2A database
 
-## How It Works
 
+### Creating an executable
+
+To directly create a windows, macos or linux executable, you can use the `--executable [windows|darwin|linux] [--arch <architecture>]` argument with the create command.
+
+This will:
+1. Temporarily install the application
+2. Create an executable and move it to your working directory
+3. Delete the application
+
+> [!WARNING]
+> To launch an executable, you will need all the files that are created by U2A.
+
+### Creating a setup
+
+You can also directly create a setup file, so people can install it on their machine. Use the `--executable [...] --setup` to do so.
+
+This will:
+1. Temporarily install the application
+2. Create an executable and move it to your working directory
+3. Create a setup file and move it to your working directory
+4. Delete the application
+
+
+> [!WARNING]
+> To use the setup, you will need all the files that are created by U2A.
+
+
+## How It Works
+  
+`This dont apply for executables and setup`
 U2A creates a minimal Electron application that loads the specified website URL. It:
 
 1. Downloads the site's favicon to use as the application icon

package/package.json

@@ -1,39 +1,42 @@
 {
     "name": "u2a",
-    "version": "2.1.8",
+    "version": "3.0.0",
     "description": "URL to App - Turn any URL into a desktop application",
     "main": "src/index.js",
     "bin": {
-      "u2a": "./src/index.js"
+        "u2a": "./src/index.js"
     },
     "scripts": {
-      "start": "node src/index.js"
+        "start": "node src/index.js"
     },
     "keywords": [
-      "cli",
-      "webapp",
-      "electron",
-      "url",
-      "desktop",
-      "build",
-      "application"
+        "cli",
+        "webapp",
+        "electron",
+        "url",
+        "desktop",
+        "build",
+        "application"
     ],
     "author": "Douxx",
     "license": "GPL-3.0-only",
     "dependencies": {
-      "axios": "^1.6.0",
-      "chalk": "^4.1.2",
-      "commander": "^10.0.0",
-      "electron": "^22.0.0",
-      "inquirer": "^8.2.5",
-      "open": "^8.4.0"
+        "axios": "^1.6.0",
+        "chalk": "^4.1.2",
+        "commander": "^10.0.0",
+        "electron": "^22.0.0",
+        "icojs": "^0.19.5",
+        "inquirer": "^8.2.5",
+        "open": "^8.4.0",
+        "png-to-ico": "^2.1.8",
+        "sharp": "^0.33.5"
     },
     "homepage": "https://urltoapp.xyz",
     "repository": {
-    "type": "git",
-    "url": "https://github.com/douxxtech/urltoapp"
-  },
-  "bugs": {
-    "url": "https://github.com/douxxtech/urltoapp/issues"
-  }
-  }
+        "type": "git",
+        "url": "https://github.com/douxxtech/urltoapp"
+    },
+    "bugs": {
+        "url": "https://github.com/douxxtech/urltoapp/issues"
+    }
+}

package/src/commands/create.js

@@ -2,7 +2,7 @@ const fs = require('fs');
 const path = require('path');
 const { execSync } = require('child_process');
 const { normalizeUrl, getDomainName } = require('../utils/url');
-const { getFavicon } = require('../utils/favicon');
+const { getFavicon, processFavicon } = require('../utils/favicon');
 const { APPS_DIR, readDB, writeDB } = require('../utils/config');
 const Logger = require('../utils/logger');
 const os = require('os');
@@ -557,7 +557,10 @@ app.on('activate', () => {
 `;
 }
 
-function generatePackageJson(appName, iconPath) {
+
+
+
+async function generatePackageJson(appName, iconPath, isExecutable = false, createSetup = false) {
   const u2aPackagePath = path.resolve(__dirname, '../../package.json');
 
   let u2aVersion = '1.0.0';
@@ -566,14 +569,19 @@ function generatePackageJson(appName, iconPath) {
     const u2aPackage = JSON.parse(u2aPackageContent);
     u2aVersion = u2aPackage.version || u2aVersion;
   } catch (error) {
-    logger.error('Error while fetching u2a package.json', error)
+    logger.error('Error while fetching u2a package.json', error);
+  }
+
+  if (createSetup) {
+    iconPath = await processFavicon(iconPath);
   }
 
-  return {
+  const packageJson = {
     name: `u2a-${appName.replace(/\s+/g, '-')}`,
     version: u2aVersion,
     description: `Web app for ${appName}`,
     main: 'main.js',
+    author: `${appName}`,
     scripts: {
       start: 'electron .'
     },
@@ -586,6 +594,201 @@ function generatePackageJson(appName, iconPath) {
       icon: iconPath
     }
   };
+
+  if (isExecutable) {
+    packageJson.devDependencies = {
+      "electron-packager": "^17.1.1",
+      "electron-builder": "^24.6.3",
+      "electron": "^22.0.0"
+    };
+
+    packageJson.dependencies = {};
+    
+    packageJson.scripts.package = "electron-packager . --overwrite --asar";
+    packageJson.scripts.setup = "electron-builder";
+  }
+
+  if (isExecutable && createSetup) {
+    packageJson.build = {
+      ...packageJson.build,
+      appId: `com.u2a.${appName.replace(/\s+/g, '-')}`,
+      productName: appName,
+      directories: {
+        output: "installer"
+      },
+      files: [
+        "**/*",
+        "!**/node_modules/*/{CHANGELOG.md,README.md,README,readme.md,readme}",
+        "!**/node_modules/*/{test,__tests__,tests,powered-test,example,examples}",
+        "!**/node_modules/*.d.ts",
+        "!**/node_modules/.bin",
+        "!**/.{idea,git,cache,build,dist}",
+        "!dist/**/*",
+        "!installer/**/*"
+      ],
+      win: {
+        target: "nsis",
+        icon: iconPath
+      },
+      mac: {
+        target: "dmg"
+      },
+      linux: {
+        target: "AppImage",
+        icon: iconPath
+      },
+      nsis: {
+        oneClick: false,
+        allowToChangeInstallationDirectory: true
+      }
+    };
+  }
+
+  return packageJson;
+}
+
+function copyFolderRecursiveSync(source, target) {
+  if (!fs.existsSync(target)) {
+    fs.mkdirSync(target, { recursive: true });
+  }
+
+  const files = fs.readdirSync(source);
+
+  files.forEach((file) => {
+    const sourcePath = path.join(source, file);
+    const targetPath = path.join(target, file);
+
+    if (fs.lstatSync(sourcePath).isDirectory()) {
+      copyFolderRecursiveSync(sourcePath, targetPath);
+    } else {
+      fs.copyFileSync(sourcePath, targetPath);
+    }
+  });
+}
+
+async function buildExecutable(appDir, appName, platform, iconPath, options) {
+  logger.info(`Building executable for ${platform}...`);
+  
+  try {
+    const installOptions = {
+      cwd: appDir,
+      stdio: ['ignore', 'pipe', 'pipe'],
+      windowsHide: true
+    };
+    
+    execSync('npm install --save-dev electron-packager electron', installOptions);
+    
+    let platformFlag = '';
+    let archFlag = `--arch=${options.arch || 'x64'}`;
+    let iconOption = '';
+    
+    switch(platform) {
+      case 'windows':
+        platformFlag = '--platform=win32';
+        iconOption = iconPath ? `--icon="${iconPath}"` : '';
+        break;
+      case 'darwin':
+        platformFlag = '--platform=darwin';
+        if (iconPath && !iconPath.endsWith('.icns')) {
+          logger.warn('MacOs Icons are not supported at this time.');
+        }
+        iconOption = iconPath ? `--icon="${iconPath}"` : '';
+        break;
+      case 'linux':
+        platformFlag = '--platform=linux';
+        iconOption = iconPath ? `--icon="${iconPath}"` : '';
+        break;
+      default:
+        platformFlag = `--platform=${process.platform}`;
+    }
+    
+    const packageCommand = `npx electron-packager . "${appName}" ${platformFlag} ${archFlag} --out=dist --overwrite --asar ${iconOption}`;
+    
+    logger.debug(`Executing: ${packageCommand}`);
+    
+    execSync(packageCommand, installOptions);
+    
+    let distPlatform = '';
+    switch(platform) {
+      case 'windows': distPlatform = 'win32'; break;
+      case 'darwin': distPlatform = 'darwin'; break;
+      case 'linux': distPlatform = 'linux'; break;
+      default: distPlatform = process.platform;
+    }
+    
+    const outputPath = path.join(appDir, 'dist', `${appName}-${distPlatform}-x64`);
+    
+    if (fs.existsSync(outputPath)) {
+      logger.debug(`Executable built successfully at: ${outputPath}`);
+      return outputPath;
+    } else {
+      logger.error(`Failed to find the built executable at: ${outputPath}`);
+      return null;
+    }
+  } catch (error) {
+    logger.error(`Error while building executable:`, error);
+    return null;
+  }
+}
+
+function remove(path) {
+  try {
+    if (fs.existsSync(path)) {
+      fs.rmSync(path, { recursive: true, force: true });
+      logger.debug(`Dir/file removed: ${path}`);
+    }
+  } catch (error) {
+    logger.error(`Error while removing dir/file ${path}`, error);
+  }
+}
+
+async function buildSetup(appDir, platform, arch) {
+  logger.info(`Building setup for ${platform}${arch ? ` (${arch})` : ''}...`);
+  
+  try {
+    const installOptions = {
+      cwd: appDir,
+      stdio: ['ignore', 'pipe', 'pipe'],
+      windowsHide: true
+    };
+    
+    execSync('npm install --save-dev electron-builder', installOptions);
+    
+    let builderArgs = '';
+    switch(platform) {
+      case 'windows':
+        builderArgs = '--win';
+        break;
+      case 'darwin':
+        builderArgs = '--mac';
+        break;
+      case 'linux':
+        builderArgs = '--linux';
+        break;
+      default:
+        builderArgs = '';
+    }
+    
+    if (arch) {
+      builderArgs += ` --${arch}`;
+    }
+    
+    const builderCommand = `npx electron-builder ${builderArgs}`;
+    logger.debug(`Executing: ${builderCommand}`);
+    execSync(builderCommand, installOptions);
+    
+    const installerPath = path.join(appDir, 'installer');
+    if (fs.existsSync(installerPath)) {
+      logger.debug(`Setup created at: ${installerPath}`);
+      return installerPath;
+    } else {
+      logger.error(`Failed to find the built installer at: ${installerPath}`);
+      return null;
+    }
+  } catch (error) {
+    logger.error(`Error while building setup:`, error);
+    return null;
+  }
 }
 
 async function createApp(url, options) {
@@ -615,8 +818,10 @@ async function createApp(url, options) {
     fs.writeFileSync(mainJsPath, mainJsContent);
     logger.debug(`main.js file created`);
 
+    const isExecutable = !!options.executable;
+    const createSetup = !!options.setup;
     const packageJsonPath = path.join(appDir, 'package.json');
-    const packageJsonContent = generatePackageJson(appName, iconPath);
+    const packageJsonContent = await generatePackageJson(appName, iconPath, isExecutable, createSetup);
     fs.writeFileSync(packageJsonPath, JSON.stringify(packageJsonContent, null, 2));
     logger.debug(`package.json file created`);
 
@@ -628,10 +833,59 @@ async function createApp(url, options) {
       windowsHide: true
     };
 
-    const stdout = execSync('npm install --only=prod', installOptions);
-    logger.debug(`npm install completed: ${stdout.toString().trim()}`);
-
-    const desktopPath = addAppToOS(appName, url, appDir, iconPath);
+    execSync('npm install --only=prod', installOptions);
+    logger.debug(`npm install completed`);
+
+    let executablePath = null;
+    let desktopPath = null;
+
+    if (isExecutable) {
+      const targetPlatform = options.executable === true ? process.platform : options.executable;
+      executablePath = await buildExecutable(appDir, appName, targetPlatform, iconPath, options);
+
+      if (options.setup) {
+        const setupPath = await buildSetup(appDir, targetPlatform, options.arch);
+        if (setupPath) {
+          logger.debug(`Setup installer created at: ${setupPath}`);
+          
+          const currentDir = process.cwd();
+          const setupTargetDir = path.join(currentDir, `${appName}-setup`);
+          
+          if (!fs.existsSync(setupTargetDir)) {
+            fs.mkdirSync(setupTargetDir, { recursive: true });
+          }
+          
+          copyFolderRecursiveSync(setupPath, setupTargetDir);
+          logger.success(`Setup installer created at: ${setupTargetDir}`);
+        }
+      }
+      
+      if (executablePath) {
+        logger.debug(`Executable created at: ${executablePath}`);
+        
+        const currentDir = process.cwd();
+        const targetDir = path.join(currentDir, `${appName}-executable`);
+        
+        if (!fs.existsSync(targetDir)) {
+          fs.mkdirSync(targetDir, { recursive: true });
+        }
+        
+        copyFolderRecursiveSync(executablePath, targetDir);
+        
+        logger.success(`Executable created at: ${targetDir}`);
+        
+        executablePath = targetDir;
+        
+        removeAppFromOS(appName);
+        remove(appDir);
+        remove(iconPath);
+        
+        logger.debug(`Temporary application files removed after executable creation`);
+        return;
+      }
+    } else {
+      desktopPath = addAppToOS(appName, url, appDir, iconPath);
+    }
 
     const appData = {
       url,
@@ -639,6 +893,7 @@ async function createApp(url, options) {
       path: appDir,
       icon: iconPath,
       desktopPath,
+      executablePath,
       name: options.name,
       width: options.width,
       height: options.height
@@ -651,12 +906,15 @@ async function createApp(url, options) {
     if (desktopPath) {
       logger.info(`A shortcut has been created in your system's applications directory`);
     }
+    if (executablePath) {
+      logger.info(`A standalone executable has been created at: ${executablePath}`);
+    }
   } catch (error) {
-    logger.error(`Error while creating an application for ${url}`, error);
+    logger.error(`Error while creating an application for ${url}: ${error}`);
   }
 }
 
 module.exports = {
   createApp,
   removeAppFromOS
-};
+};

package/src/index.js

@@ -20,6 +20,9 @@ program
   .option('--name <name>', 'Specify the application name')
   .option('--width <width>', 'Specify the window width', parseInt)
   .option('--height <height>', 'Specify the window height', parseInt)
+  .option('--executable [windows|darwin|linux]', 'Create a single executable for the target system')
+  .option('--arch [x64|armv7l|arm64|universal]', 'Specify the target architecture for the executable')
+  .option('--setup', 'Creates a setup file for the executable')
   .action((url, options) => {
     createApp(url, options);
   });

package/src/utils/favicon.js

@@ -4,6 +4,10 @@ const axios = require('axios');
 const { APPS_DIR } = require('./config');
 const { normalizeUrl, getDomainName } = require('./url');
 const Logger = require('./logger');
+const { parseICO} = require('icojs');
+const sharp = require('sharp');
+const pngToIco = require('png-to-ico');
+
 
 const logger = new Logger('favicon');
 
@@ -19,7 +23,7 @@ async function getFavicon(url) {
     const iconResponse = await axios.get(faviconUrl, { responseType: 'arraybuffer' });
 
     const contentType = iconResponse.headers['content-type'];
-    let fileExtension = '.ico'; // Default extension
+    let fileExtension = '.ico';
     if (contentType.includes('png')) {
       fileExtension = '.png';
     } else if (contentType.includes('jpeg') || contentType.includes('jpg')) {
@@ -44,6 +48,51 @@ async function getFavicon(url) {
   }
 }
 
+async function processFavicon(iconPath) {
+  const dir = path.dirname(iconPath);
+  const ext = path.extname(iconPath);
+  const baseName = path.basename(iconPath, ext);
+
+  if (baseName === 'favicon' && ext === '.ico') {
+    const newPath = path.join(dir, 'favicon256.ico');
+    fs.copyFileSync(iconPath, newPath);
+    logger.debug("Default favicon.ico updated to favicon256.ico");
+    return newPath;
+  } else {
+    try {
+      const icoBuffer = fs.readFileSync(iconPath);
+      const images = await parseICO(icoBuffer, 'image/png');
+
+      if (images && images.length > 0) {
+        const pngBuffer = Buffer.from(images[0].buffer);
+        const tempPngPath = iconPath + '.png';
+        const resizedPngPath = iconPath + '_resized.png';
+
+        fs.writeFileSync(tempPngPath, pngBuffer);
+
+        await sharp(tempPngPath)
+          .resize(256, 256)
+          .toFile(resizedPngPath);
+
+        fs.renameSync(resizedPngPath, tempPngPath);
+
+        const newIcoBuffer = await pngToIco([tempPngPath]);
+        fs.writeFileSync(iconPath, newIcoBuffer);
+        fs.unlinkSync(tempPngPath);
+
+        logger.warn(`To proceed to setup, favicon has been resized to 256x256. Quality loss is possible.`);
+        return iconPath;
+      }
+    } catch (error) {
+      logger.error('Error processing ICO file:', error);
+      return iconPath;
+    }
+  }
+}
+
+
+
 module.exports = {
-  getFavicon
+  getFavicon,
+  processFavicon
 };

package/src/utils/logger.js

@@ -41,7 +41,7 @@ class Logger {
   }
 
   error(message, error = null) {
-    const formattedMessage = this._format('ERROR', message);
+    const formattedMessage = this._format('ERROR', `${message} ${error}`);
     console.log(chalk.red(formattedMessage));
     this._writeToFile(formattedMessage);