u2a 1.0.0

package/README.md

@@ -0,0 +1,123 @@
+# U2A (URL to App)
+
+![U2A Banner](https://img.shields.io/badge/U2A-URL%20to%20App-blue)
+![License](https://img.shields.io/badge/license-GPL--3.0-green)
+![Version](https://img.shields.io/badge/version-1.0.0-orange)
+
+**Convert any website into a desktop application with a single command.**
+
+U2A is a command-line utility that allows you to transform any web URL into a standalone desktop application using Electron. It works across Windows, macOS, and Linux platforms.
+
+## Features
+
+- 🚀 Transform any website into a desktop app with one command
+- 🖥️ Cross-platform support (Windows, macOS, Linux)
+- 🔄 Automatic favicon retrieval for app icons
+- 📋 Easy management of created applications
+- 📊 Detailed logging for troubleshooting
+
+## Installation
+
+```bash
+npm install -g u2a
+```
+
+## Usage
+
+### Creating an App
+
+To create a desktop application from a website:
+
+```bash
+u2a create <url>
+```
+
+Example:
+```bash
+u2a create github.com
+```
+
+This will:
+1. Download the website's favicon (if available)
+2. Create an Electron wrapper application
+3. Add the application to your system menu/launcher
+4. Track the application in the U2A database
+
+### Listing Your Apps
+
+To see all the applications you've created:
+
+```bash
+u2a list
+```
+
+This will display a list of all created applications with their details:
+- Domain name
+- Original URL
+- Creation date
+- Application directory
+
+### Removing an App
+
+To remove an application:
+
+```bash
+u2a remove <url>
+```
+
+Example:
+```bash
+u2a remove github.com
+```
+
+This will:
+1. Remove the application from your system menu/launcher
+2. Delete the application files
+3. Remove the entry from the U2A database
+
+## How It Works
+
+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
+2. Generates a main.js file with Electron configuration
+3. Creates a package.json with necessary dependencies
+4. Installs required Node modules
+5. Adds appropriate desktop integration for your operating system
+6. Maintains a database of created applications for easy management
+
+## System Requirements
+
+- Node.js 12.0 or higher
+- npm 6.0 or higher
+- Windows, macOS, or Linux
+
+## Configuration
+
+U2A stores all configuration, application data, and logs in the `.u2a` directory in your home folder:
+
+- `~/.u2a/apps/` - Application files
+- `~/.u2a/logs/` - Log files
+- `~/.u2a/db.json` - Application database
+
+## Troubleshooting
+
+If you encounter any issues, check the log files in the `~/.u2a/logs/` directory. Each component has its own log file with detailed information.
+
+Set the `DEBUG` environment variable to see additional debug messages:
+
+```bash
+DEBUG=1 u2a create example.com
+```
+
+## License
+
+This project is licensed under the GNU General Public License v3.0 - see the [LICENSE](LICENSE) file for details.
+
+## 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

@@ -0,0 +1,32 @@
+{
+    "name": "u2a",
+    "version": "1.0.0",
+    "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"
+    },
+    "keywords": [
+      "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"
+    },
+    "homepage": "https://douxx.tech"
+  }

package/src/commands/create.js

@@ -0,0 +1,333 @@
+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 { APPS_DIR, readDB, writeDB } = require('../utils/config');
+const Logger = require('../utils/logger');
+const os = require('os');
+const { isContext } = require('vm');
+
+const logger = new Logger('create');
+
+function createWindowsShortcut(appInfo) {
+  try {
+    const { domain, 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 targetPath = path.join(appDir, 'node_modules', '.bin', 'electron.cmd');
+    const workingDir = appDir;
+
+    const psScript = `
+      $WshShell = New-Object -comObject WScript.Shell
+      $Shortcut = $WshShell.CreateShortcut("${shortcutPath.replace(/\\/g, '\\\\')}")
+      $Shortcut.TargetPath = "${targetPath.replace(/\\/g, '\\\\')}"
+      $Shortcut.Arguments = "."
+      $Shortcut.WorkingDirectory = "${workingDir.replace(/\\/g, '\\\\')}"
+      $Shortcut.IconLocation = "${iconPath.replace(/\\/g, '\\\\')}"
+      $Shortcut.Description = "Application Web pour ${domain}"
+      $Shortcut.Save()
+    `;
+
+    const tempScriptPath = path.join(os.tmpdir(), `create_shortcut_${domain}.ps1`);
+    fs.writeFileSync(tempScriptPath, psScript);
+
+    execSync(`powershell -ExecutionPolicy Bypass -File "${tempScriptPath}"`, {
+      stdio: ['ignore', 'pipe', 'pipe'],
+      windowsHide: true
+    });
+
+    fs.unlinkSync(tempScriptPath);
+
+    logger.success(`Shortcut created in the Start Menu: ${shortcutPath}`);
+    return shortcutPath;
+  } catch (error) {
+    logger.error(`Error while creating the Windows shortcut`, error);
+    return null;
+  }
+}
+
+
+function createLinuxDesktopEntry(appInfo) {
+  try {
+    const { domain, url, appDir, iconPath } = appInfo;
+    const appsDir = path.join(os.homedir(), '.local', 'share', 'applications');
+
+    if (!fs.existsSync(appsDir)) {
+      fs.mkdirSync(appsDir, { recursive: true });
+    }
+
+    const desktopEntry = `[Desktop Entry]
+Type=Application
+Name=${domain}
+Exec=${path.join(appDir, 'node_modules', '.bin', 'electron')} ${path.join(appDir, 'main.js')}
+Icon=${iconPath}
+Comment=Application Web pour ${url}
+Categories=Network;WebBrowser;
+Terminal=false
+`;
+
+    const desktopFilePath = path.join(appsDir, `u2a-${domain}.desktop`);
+    fs.writeFileSync(desktopFilePath, desktopEntry);
+
+    fs.chmodSync(desktopFilePath, '755');
+
+    logger.success(`Desktop entry created for Linux: ${desktopFilePath}`);
+    return desktopFilePath;
+  } catch (error) {
+    logger.error(`Error while creating the Linux desktop entry`, error);
+    return null;
+  }
+}
+
+function createMacOSApp(appInfo) {
+  try {
+    const { domain, 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 macOsPath = path.join(appPath, 'Contents', 'MacOS');
+    const resourcesPath = path.join(appPath, 'Contents', 'Resources');
+
+    fs.mkdirSync(path.join(appPath, 'Contents', 'MacOS'), { recursive: true });
+    fs.mkdirSync(resourcesPath, { recursive: true });
+
+    const infoPlist = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>CFBundleExecutable</key>
+    <string>AppRunner</string>
+    <key>CFBundleIconFile</key>
+    <string>icon.icns</string>
+    <key>CFBundleIdentifier</key>
+    <string>com.u2a.${domain}</string>
+    <key>CFBundleName</key>
+    <string>${domain}</string>
+    <key>CFBundleDisplayName</key>
+    <string>${domain}</string>
+    <key>CFBundlePackageType</key>
+    <string>APPL</string>
+    <key>CFBundleVersion</key>
+    <string>1.0</string>
+    <key>CFBundleShortVersionString</key>
+    <string>1.0</string>
+</dict>
+</plist>`;
+
+    fs.writeFileSync(path.join(appPath, 'Contents', 'Info.plist'), infoPlist);
+
+    const shellScript = `#!/bin/bash
+cd "${appDir}"
+"${path.join(appDir, 'node_modules', '.bin', 'electron')}" "${path.join(appDir, 'main.js')}"`;
+
+    const shellScriptPath = path.join(macOsPath, 'AppRunner');
+    fs.writeFileSync(shellScriptPath, shellScript);
+    fs.chmodSync(shellScriptPath, '755');
+
+    fs.copyFileSync(iconPath, path.join(resourcesPath, 'icon.icns'));
+
+    logger.success(`macOS application created: ${appPath}`);
+    return appPath;
+  } catch (error) {
+    logger.error(`Error while creating the macOS application`, error);
+    return null;
+  }
+}
+
+function addAppToOS(domain, url, appDir, iconPath) {
+  const appInfo = { domain, url, appDir, iconPath };
+  let desktopPath = null;
+
+  if (process.platform === 'win32') {
+    desktopPath = createWindowsShortcut(appInfo);
+  } else if (process.platform === 'darwin') {
+    desktopPath = createMacOSApp(appInfo);
+  } else if (process.platform === 'linux') {
+    desktopPath = createLinuxDesktopEntry(appInfo);
+  } else {
+    logger.warn(`Desktop integration not supported for platform ${process.platform}`);
+  }
+
+  return desktopPath;
+}
+
+function removeAppFromOS(domain) {
+  try {
+    if (process.platform === 'win32') {
+      const startMenuPath = path.join(process.env.APPDATA, 'Microsoft', 'Windows', 'Start Menu', 'Programs', 'U2A Apps', `${domain}.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`);
+      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`);
+      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);
+  }
+}
+
+function generateMainJs(domain, url, iconPath) {
+  return `
+const { app, BrowserWindow, Menu, shell } = require('electron');
+const path = require('path');
+
+let mainWindow;
+
+function createWindow() {
+  app.setAppUserModelId("${domain}");
+
+  mainWindow = new BrowserWindow({
+    width: 1200,
+    height: 800,
+    title: "${domain}",
+    icon: "${iconPath.replace(/\\/g, '\\\\')}",
+    webPreferences: {
+      nodeIntegration: false,
+      contextIsolation: true
+    }
+  });
+
+  mainWindow.loadURL("${url}");
+
+  mainWindow.webContents.on('new-window', (event, url) => {
+    event.preventDefault();
+    shell.openExternal(url);
+  });
+
+  const template = [];
+
+  const menu = Menu.buildFromTemplate(template);
+  Menu.setApplicationMenu(menu);
+}
+
+if (process.platform === 'win32') {
+  app.setAppUserModelId(app.name);
+}
+
+app.whenReady().then(createWindow);
+
+app.on('window-all-closed', () => {
+  if (process.platform !== 'darwin') {
+    app.quit();
+  }
+});
+
+app.on('activate', () => {
+  if (BrowserWindow.getAllWindows().length === 0) {
+    createWindow();
+  }
+});
+`;
+}
+function generatePackageJson(domain, iconPath) {
+  return {
+    name: `u2a-${domain}`,
+    version: '1.0.0',
+    description: `Web app for ${domain}`,
+    main: 'main.js',
+    scripts: {
+      start: 'electron .'
+    },
+    dependencies: {
+      electron: '^22.0.0'
+    },
+    build: {
+      appId: `com.u2a.${domain.replace(/\./g, '-')}`,
+      productName: domain,
+      icon: iconPath
+    }
+  };
+}
+
+async function createApp(url) {
+  logger.info(`Creating application for ${url}`);
+
+  try {
+    url = normalizeUrl(url);
+    const domain = getDomainName(url);
+
+    const db = readDB();
+    if (db.hasOwnProperty(domain)) {
+      logger.warn(`Application for ${domain} already exists`);
+      return;
+    }
+
+    const iconPath = await getFavicon(url);
+
+    const appDir = path.join(APPS_DIR, domain);
+    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);
+    fs.writeFileSync(mainJsPath, mainJsContent);
+    logger.debug(`main.js file created`);
+
+    const packageJsonPath = path.join(appDir, 'package.json');
+    const packageJsonContent = generatePackageJson(domain, iconPath);
+    fs.writeFileSync(packageJsonPath, JSON.stringify(packageJsonContent, null, 2));
+    logger.debug(`package.json file created`);
+
+    logger.info(`Installing dependencies for ${domain}`);
+
+    const installOptions = {
+      cwd: appDir,
+      stdio: ['ignore', 'pipe', 'pipe'],
+      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);
+
+    const appData = {
+      url,
+      created: new Date().toISOString(),
+      path: appDir,
+      icon: iconPath,
+      desktopPath
+    };
+
+    db[domain] = 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`);
+    }
+  } catch (error) {
+    logger.error(`Error while creating an application for ${url}`, error);
+  }
+}
+
+module.exports = {
+  createApp,
+  removeAppFromOS
+};

package/src/commands/list.js

@@ -0,0 +1,33 @@
+const { readDB } = require('../utils/config');
+const Logger = require('../utils/logger');
+const chalk = require('chalk');
+
+const logger = new Logger('list');
+
+function listApps() {
+  const apps = readDB();
+
+  if (Object.keys(apps).length === 0) {
+    logger.warn('No applications have been created');
+    logger.info('Create one with: u2a create <url>');
+    return;
+  }
+
+  logger.info('Available applications:');
+  console.log(chalk.gray('--------------------------------'));
+
+  Object.entries(apps).forEach(([domain, info]) => {
+    logger.debug(`Retrieved information for ${domain}:`, info);
+    console.log(chalk.green(`\n${domain}:`));
+    console.log(chalk.blue(`  URL: ${info.url}`));
+    console.log(chalk.blue(`  Created on: ${new Date(info.created).toLocaleString()}`));
+    console.log(chalk.blue(`  Directory: ${info.path}`));
+    console.log(chalk.gray('  ----------'));
+  });
+
+  logger.info('To remove an application: u2a remove <domain>');
+}
+
+module.exports = {
+  listApps
+};

package/src/commands/remove.js

@@ -0,0 +1,59 @@
+const fs = require('fs');
+const inquirer = require('inquirer');
+const { normalizeUrl, getDomainName } = require('../utils/url');
+const { readDB, writeDB, APPS_DIR } = require('../utils/config');
+const Logger = require('../utils/logger');
+const { removeAppFromOS } = require('./create');
+const path = require('path');
+
+const logger = new Logger('remove');
+
+async function removeApp(url) {
+  try {
+    const domain = getDomainName(normalizeUrl(url));
+    const db = readDB();
+
+    if (!db.hasOwnProperty(domain)) {
+      logger.warn(`The application for ${domain} does not exist`);
+      return;
+    }
+
+    const { confirm } = await inquirer.prompt([
+      {
+        type: 'confirm',
+        name: 'confirm',
+        message: `Are you sure you want to remove the application for ${domain}?`,
+        default: false
+      }
+    ]);
+
+    if (!confirm) {
+      logger.info('Operation canceled');
+      return;
+    }
+
+    const appInfo = db[domain];
+    const appDir = appInfo.path;
+
+    removeAppFromOS(domain);
+    logger.info(`Removing the application ${domain}...`);
+
+    const iconPath = path.join(APPS_DIR, `${domain}.ico`);
+    if (fs.existsSync(iconPath)) {
+      fs.unlinkSync(iconPath);
+      logger.success(`Icon for ${domain} removed`);
+    }
+
+    fs.rmSync(appDir, { recursive: true, force: true });
+    delete db[domain];
+    writeDB(db);
+
+    logger.success(`The application for ${domain} has been successfully removed`);
+  } catch (error) {
+    logger.error(`Error removing the application ${url}`, error);
+  }
+}
+
+module.exports = {
+  removeApp
+};

package/src/index.js

@@ -0,0 +1,42 @@
+#!/usr/bin/env node
+
+const { program } = require('commander');
+const { createApp } = require('./commands/create');
+const { listApps } = require('./commands/list');
+const { removeApp } = require('./commands/remove');
+const { version } = require('../package.json');
+const { setupConfig } = require('./utils/config');
+
+setupConfig();
+
+program
+  .name('u2a')
+  .description('Convert websites into desktop applications')
+  .version(version);
+
+program
+  .command('create <url>')
+  .description('Create a new application from a URL')
+  .action(createApp);
+
+program
+  .command('list')
+  .description('List all available applications')
+  .action(listApps);
+
+program
+  .command('remove <url>')
+  .description('Remove an existing application')
+  .action(removeApp);
+
+program.on('command:*', () => {
+  console.error(`\nInvalid command: ${program.args.join(' ')}`);
+  console.log(`\nUse --help to see the list of available commands.`);
+  process.exit(1);
+});
+
+program.parse(process.argv);
+
+if (process.argv.length <= 2) {
+  program.help();
+}

package/src/utils/config.js

@@ -0,0 +1,48 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+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');
+
+function setupConfig() {
+  if (!fs.existsSync(CONFIG_DIR)) {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+  if (!fs.existsSync(APPS_DIR)) {
+    fs.mkdirSync(APPS_DIR, { recursive: true });
+  }
+  if (!fs.existsSync(LOGS_DIR)) {
+    fs.mkdirSync(LOGS_DIR, { recursive: true });
+  }
+  if (!fs.existsSync(DB_PATH)) {
+    fs.writeFileSync(DB_PATH, JSON.stringify({}, null, 2));
+  }
+}
+
+function readDB() {
+  return JSON.parse(fs.readFileSync(DB_PATH, 'utf-8'));
+}
+
+function writeDB(data) {
+  fs.writeFileSync(DB_PATH, JSON.stringify(data, null, 2));
+}
+
+function addAppToDB(domain, appData) {
+  const db = readDB();
+  db[domain] = appData;
+  writeDB(db);
+  logger.debug(`Application recorded in the database:`, domain);
+}
+
+module.exports = {
+  CONFIG_DIR,
+  APPS_DIR,
+  LOGS_DIR,
+  setupConfig,
+  readDB,
+  writeDB,
+  addAppToDB
+};