u2a 2.1.6 → 3.0.0

package/README.md

@@ -1,10 +1,10 @@
 <div align="center">
-  <a href="#" 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" 
-      type="image/svg+xml" 
-      style="border-radius: 20px; overflow: hidden;" 
+  <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"
+      type="image/svg+xml"
+      style="border-radius: 20px; overflow: hidden;"
     />
     <h1 align="center">U2A (URL to App)</h1>
   </a>
@@ -25,6 +25,7 @@ U2A is a command-line utility that allows you to transform any web URL into a st
 - 🔄 Automatic favicon retrieval for app icons
 - 📋 Easy management of created applications
 - 📊 Detailed logging for troubleshooting
+- 🏷️ Customizable application names and window sizes
 
 ## Installation
 
@@ -39,17 +40,17 @@ npm install -g u2a
 To create a desktop application from a website:
 
 ```bash
-u2a create <url>
+u2a create <url> [--name <appName>] [--width <width>] [--height <height>]
 ```
 
 Example:
 ```bash
-u2a create github.com
+u2a create github.com --name "GitHub App" --width 1200 --height 800
 ```
 
 This will:
 1. Download the website's favicon (if available)
-2. Create an Electron wrapper application
+2. Create an Electron wrapper application with the specified name and window size
 3. Add the application to your system menu/launcher
 4. Track the application in the U2A database
 
@@ -62,7 +63,7 @@ u2a list
 ```
 
 This will display a list of all created applications with their details:
-- Domain name
+- Application name
 - Original URL
 - Creation date
 - Application directory
@@ -72,12 +73,12 @@ This will display a list of all created applications with their details:
 To remove an application:
 
 ```bash
-u2a remove <url>
+u2a remove <appName>
 ```
 
 Example:
 ```bash
-u2a remove github.com
+u2a remove "GitHub App"
 ```
 
 This will:
@@ -85,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
@@ -127,7 +157,3 @@ This project is licensed under the GNU General Public License v3.0 - see the [LI
 ## Author
 
 Created by [Douxx](https://douxx.tech)
-
-## Disclaimer
-
-This tool is for personal use only. Always respect the terms of service of websites you convert to desktop apps.

package/package.json

@@ -1,39 +1,42 @@
 {
     "name": "u2a",
-    "version": "2.1.6",
+    "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');
@@ -11,14 +11,14 @@ const logger = new Logger('create');
 
 function createWindowsShortcut(appInfo) {
   try {
-    const { domain, appDir, iconPath } = appInfo;
+    const { appName, appDir, iconPath } = appInfo;
     const startMenuPath = path.join(process.env.APPDATA, 'Microsoft', 'Windows', 'Start Menu', 'Programs', 'U2A Apps');
 
     if (!fs.existsSync(startMenuPath)) {
       fs.mkdirSync(startMenuPath, { recursive: true });
     }
 
-    const shortcutPath = path.join(startMenuPath, `${domain}.lnk`);
+    const shortcutPath = path.join(startMenuPath, `${appName}.lnk`);
     const targetPath = path.join(appDir, 'node_modules', '.bin', 'electron.cmd');
     const workingDir = appDir;
 
@@ -29,11 +29,11 @@ function createWindowsShortcut(appInfo) {
       $Shortcut.Arguments = "."
       $Shortcut.WorkingDirectory = "${workingDir.replace(/\\/g, '\\\\')}"
       $Shortcut.IconLocation = "${iconPath.replace(/\\/g, '\\\\')}"
-      $Shortcut.Description = "Application Web pour ${domain}"
+      $Shortcut.Description = "Application Web pour ${appName}"
       $Shortcut.Save()
     `;
 
-    const tempScriptPath = path.join(os.tmpdir(), `create_shortcut_${domain}.ps1`);
+    const tempScriptPath = path.join(os.tmpdir(), `create_shortcut_${appName}.ps1`);
     fs.writeFileSync(tempScriptPath, psScript);
 
     execSync(`powershell -ExecutionPolicy Bypass -File "${tempScriptPath}"`, {
@@ -53,7 +53,7 @@ function createWindowsShortcut(appInfo) {
 
 function createLinuxDesktopEntry(appInfo) {
   try {
-    const { domain, url, appDir, iconPath } = appInfo;
+    const { appName, url, appDir, iconPath } = appInfo;
     const appsDir = path.join(os.homedir(), '.local', 'share', 'applications');
 
     if (!fs.existsSync(appsDir)) {
@@ -62,7 +62,7 @@ function createLinuxDesktopEntry(appInfo) {
 
     const desktopEntry = `[Desktop Entry]
 Type=Application
-Name=${domain}
+Name=${appName}
 Exec=${path.join(appDir, 'node_modules', '.bin', 'electron')} ${path.join(appDir, 'main.js')}
 Icon=${iconPath}
 Comment=Application Web pour ${url}
@@ -70,7 +70,7 @@ Categories=Network;WebBrowser;
 Terminal=false
 `;
 
-    const desktopFilePath = path.join(appsDir, `u2a-${domain}.desktop`);
+    const desktopFilePath = path.join(appsDir, `u2a-${appName}.desktop`);
     fs.writeFileSync(desktopFilePath, desktopEntry);
 
     fs.chmodSync(desktopFilePath, '755');
@@ -85,15 +85,14 @@ Terminal=false
 
 function createMacOSApp(appInfo) {
   try {
-    const { domain, appDir, iconPath } = appInfo;
+    const { appName, appDir, iconPath } = appInfo;
     const appsDir = path.join(os.homedir(), 'Applications', 'U2A Apps');
 
     if (!fs.existsSync(appsDir)) {
       fs.mkdirSync(appsDir, { recursive: true });
     }
 
-    const appName = `${domain}.app`;
-    const appPath = path.join(appsDir, appName);
+    const appPath = path.join(appsDir, `${appName}.app`);
     const macOsPath = path.join(appPath, 'Contents', 'MacOS');
     const resourcesPath = path.join(appPath, 'Contents', 'Resources');
 
@@ -109,11 +108,11 @@ function createMacOSApp(appInfo) {
     <key>CFBundleIconFile</key>
     <string>icon.icns</string>
     <key>CFBundleIdentifier</key>
-    <string>com.u2a.${domain}</string>
+    <string>com.u2a.${appName.replace(/\s+/g, '-')}</string>
     <key>CFBundleName</key>
-    <string>${domain}</string>
+    <string>${appName}</string>
     <key>CFBundleDisplayName</key>
-    <string>${domain}</string>
+    <string>${appName}</string>
     <key>CFBundlePackageType</key>
     <string>APPL</string>
     <key>CFBundleVersion</key>
@@ -143,8 +142,8 @@ cd "${appDir}"
   }
 }
 
-function addAppToOS(domain, url, appDir, iconPath) {
-  const appInfo = { domain, url, appDir, iconPath };
+function addAppToOS(appName, url, appDir, iconPath) {
+  const appInfo = { appName, url, appDir, iconPath };
   let desktopPath = null;
 
   if (process.platform === 'win32') {
@@ -160,41 +159,46 @@ function addAppToOS(domain, url, appDir, iconPath) {
   return desktopPath;
 }
 
-function removeAppFromOS(domain) {
+function removeAppFromOS(appName) {
   try {
     if (process.platform === 'win32') {
-      const startMenuPath = path.join(process.env.APPDATA, 'Microsoft', 'Windows', 'Start Menu', 'Programs', 'U2A Apps', `${domain}.lnk`);
+      const startMenuPath = path.join(process.env.APPDATA, 'Microsoft', 'Windows', 'Start Menu', 'Programs', 'U2A Apps', `${appName}.lnk`);
       if (fs.existsSync(startMenuPath)) {
         fs.unlinkSync(startMenuPath);
         logger.success(`Shortcut removed from the Start Menu: ${startMenuPath}`);
       }
     } else if (process.platform === 'darwin') {
-      const appPath = path.join(os.homedir(), 'Applications', 'U2A Apps', `${domain}.app`);
+      const appPath = path.join(os.homedir(), 'Applications', 'U2A Apps', `${appName}.app`);
       if (fs.existsSync(appPath)) {
         fs.rmSync(appPath, { recursive: true, force: true });
         logger.success(`macOS application removed: ${appPath}`);
       }
     } else if (process.platform === 'linux') {
-      const desktopFilePath = path.join(os.homedir(), '.local', 'share', 'applications', `u2a-${domain}.desktop`);
+      const desktopFilePath = path.join(os.homedir(), '.local', 'share', 'applications', `u2a-${appName}.desktop`);
       if (fs.existsSync(desktopFilePath)) {
         fs.unlinkSync(desktopFilePath);
         logger.success(`Linux desktop entry removed: ${desktopFilePath}`);
       }
     }
   } catch (error) {
-    logger.error(`Error while removing desktop integration for ${domain}`, error);
+    logger.error(`Error while removing desktop integration for ${appName}`, error);
   }
 }
 
-function generateMainJs(domain, url, iconPath) {
+function generateMainJs(appName, url, iconPath, options = {}) {
+  const width = options.width || 1200;
+  const height = options.height || 800;
+
   return `
 const { app, BrowserWindow, Menu, shell } = require('electron');
 const path = require('path');
 const fs = require('fs');
 
-const APP_DOMAIN = "${domain}";
+const APP_NAME = "${appName}";
 const APP_URL = "${url}";
 const APP_ICON_PATH = "${iconPath.replace(/\\/g, '\\\\')}";
+const WINDOW_WIDTH = ${width};
+const WINDOW_HEIGHT = ${height};
 
 let mainWindow;
 let splashWindow;
@@ -214,7 +218,7 @@ function logAppInfo() {
   console.log('\\n--------------------------------');
   console.log('  APPLICATION INFORMATION');
   console.log('--------------------------------');
-  console.log(\`Application: \${APP_DOMAIN}\`);
+  console.log(\`Application: \${APP_NAME}\`);
   console.log(\`URL: \${APP_URL}\`);
   console.log(\`Started at: \${new Date().toLocaleString()}\`);
   console.log(\`App directory: \${__dirname}\`);
@@ -390,7 +394,7 @@ function createSplashScreen() {
   </head>
   <body>
     <div class="container">
-      <div class="domain">\${APP_DOMAIN}</div>
+      <div class="domain">\${APP_NAME}</div>
       <div class="spinner"></div>
       <div id="loading-text" class="loading-text">Loading...</div>
       <div class="progress-bar">
@@ -413,7 +417,7 @@ function createSplashScreen() {
   </html>
   \`;
 
-  const splashPath = path.join(app.getPath('temp'), \`\${APP_DOMAIN}-splash.html\`);
+  const splashPath = path.join(app.getPath('temp'), \`\${APP_NAME}-splash.html\`);
   fs.writeFileSync(splashPath, splashHtml);
 
   splashWindow.loadFile(splashPath);
@@ -423,12 +427,12 @@ function createSplashScreen() {
 function createWindow() {
   logAppInfo();
 
-  app.setAppUserModelId(APP_DOMAIN);
+  app.setAppUserModelId(APP_NAME);
 
   mainWindow = new BrowserWindow({
-    width: 1200,
-    height: 800,
-    title: APP_DOMAIN,
+    width: WINDOW_WIDTH,
+    height: WINDOW_HEIGHT,
+    title: APP_NAME,
     icon: APP_ICON_PATH,
     show: false,
     webPreferences: {
@@ -470,7 +474,7 @@ function createWindow() {
   });
 
   mainWindow.webContents.on('did-start-loading', () => {
-    updateSplashScreen('Connecting to ' + APP_DOMAIN + '...');
+    updateSplashScreen('Connecting to ' + APP_NAME + '...');
   });
 
   mainWindow.webContents.on('did-start-navigation', (event, url) => {
@@ -553,7 +557,10 @@ app.on('activate', () => {
 `;
 }
 
-function generatePackageJson(domain, iconPath) {
+
+
+
+async function generatePackageJson(appName, iconPath, isExecutable = false, createSetup = false) {
   const u2aPackagePath = path.resolve(__dirname, '../../package.json');
 
   let u2aVersion = '1.0.0';
@@ -562,14 +569,19 @@ function generatePackageJson(domain, 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);
   }
 
-  return {
-    name: `u2a-${domain}`,
+  if (createSetup) {
+    iconPath = await processFavicon(iconPath);
+  }
+
+  const packageJson = {
+    name: `u2a-${appName.replace(/\s+/g, '-')}`,
     version: u2aVersion,
-    description: `Web app for ${domain}`,
+    description: `Web app for ${appName}`,
     main: 'main.js',
+    author: `${appName}`,
     scripts: {
       start: 'electron .'
     },
@@ -577,45 +589,243 @@ function generatePackageJson(domain, iconPath) {
       electron: '^22.0.0'
     },
     build: {
-      appId: `com.u2a.${domain.replace(/\./g, '-')}`,
-      productName: domain,
+      appId: `com.u2a.${appName.replace(/\s+/g, '-')}`,
+      productName: appName,
       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;
 }
 
-async function createApp(url) {
+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) {
   logger.info(`Creating application for ${url}`);
 
   try {
     url = await normalizeUrl(url);
     const domain = getDomainName(url);
+    const appName = options.name || domain;
 
     const db = readDB();
-    if (db.hasOwnProperty(domain)) {
-      logger.warn(`Application for ${domain} already exists`);
+    if (db.hasOwnProperty(appName)) {
+      logger.warn(`Application for ${appName} already exists`);
       return;
     }
 
     const iconPath = await getFavicon(url);
 
-    const appDir = path.join(APPS_DIR, domain);
+    const appDir = path.join(APPS_DIR, appName);
     if (!fs.existsSync(appDir)) {
       fs.mkdirSync(appDir, { recursive: true });
       logger.debug(`Directory created: ${appDir}`);
     }
 
     const mainJsPath = path.join(appDir, 'main.js');
-    const mainJsContent = generateMainJs(domain, url, iconPath);
+    const mainJsContent = generateMainJs(appName, url, iconPath, 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(domain, iconPath);
+    const packageJsonContent = await generatePackageJson(appName, iconPath, isExecutable, createSetup);
     fs.writeFileSync(packageJsonPath, JSON.stringify(packageJsonContent, null, 2));
     logger.debug(`package.json file created`);
 
-    logger.info(`Installing dependencies for ${domain}`);
+    logger.info(`Installing dependencies for ${appName}`);
 
     const installOptions = {
       cwd: appDir,
@@ -623,32 +833,88 @@ async function createApp(url) {
       windowsHide: true
     };
 
-    const stdout = execSync('npm install --only=prod', installOptions);
-    logger.debug(`npm install completed: ${stdout.toString().trim()}`);
-
-    const desktopPath = addAppToOS(domain, 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,
       created: new Date().toISOString(),
       path: appDir,
       icon: iconPath,
-      desktopPath
+      desktopPath,
+      executablePath,
+      name: options.name,
+      width: options.width,
+      height: options.height
     };
 
-    db[domain] = appData;
+    db[appName] = appData;
     writeDB(db);
 
     logger.success(`Application successfully created for ${url}`);
     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/commands/remove.js

@@ -8,13 +8,12 @@ const path = require('path');
 
 const logger = new Logger('remove');
 
-async function removeApp(url) {
+async function removeApp(appName) {
   try {
-    const domain = getDomainName(await normalizeUrl(url));
     const db = readDB();
 
-    if (!db.hasOwnProperty(domain)) {
-      logger.warn(`The application for ${domain} does not exist`);
+    if (!db.hasOwnProperty(appName)) {
+      logger.warn(`The application for ${appName} does not exist`);
       return;
     }
 
@@ -22,7 +21,7 @@ async function removeApp(url) {
       {
         type: 'confirm',
         name: 'confirm',
-        message: `Are you sure you want to remove the application for ${domain}?`,
+        message: `Are you sure you want to remove the application for ${appName}?`,
         default: false
       }
     ]);
@@ -32,25 +31,25 @@ async function removeApp(url) {
       return;
     }
 
-    const appInfo = db[domain];
+    const appInfo = db[appName];
     const appDir = appInfo.path;
 
-    removeAppFromOS(domain);
-    logger.info(`Removing the application ${domain}...`);
+    removeAppFromOS(appName);
+    logger.info(`Removing the application ${appName}...`);
 
-    const iconPath = path.join(APPS_DIR, `${domain}.ico`);
+    const iconPath = path.join(APPS_DIR, `${appName}.ico`);
     if (fs.existsSync(iconPath)) {
       fs.unlinkSync(iconPath);
-      logger.success(`Icon for ${domain} removed`);
+      logger.success(`Icon for ${appName} removed`);
     }
 
     fs.rmSync(appDir, { recursive: true, force: true });
-    delete db[domain];
+    delete db[appName];
     writeDB(db);
 
-    logger.success(`The application for ${domain} has been successfully removed`);
+    logger.success(`The application for ${appName} has been successfully removed`);
   } catch (error) {
-    logger.error(`Error removing the application ${url}`, error);
+    logger.error(`Error removing the application ${appName}`, error);
   }
 }
 

package/src/index.js

@@ -14,10 +14,18 @@ program
   .description('Convert websites into desktop applications')
   .version(version);
 
-program
+  program
   .command('create <url>')
   .description('Create a new application from a URL')
-  .action(createApp);
+  .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);
+  });
 
 program
   .command('list')

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);