deskify-cli 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ipvdan (and contributors)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,95 @@
+# Deskify 🚀
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Node.js Version](https://img.shields.io/badge/node-%3E%3D14.0.0-blue.svg)](https://nodejs.org/)
+[![Platform](https://img.shields.io/badge/platform-Linux-orange.svg)](#)
+
+An ambitious, interactive, and **zero-dependency** CLI tool designed to effortlessly convert any web page into a native-feeling Linux desktop application using Electron (via Nativefier) in a single command.
+
+```text
+      _           _   _  __       
+   __| | ___  ___| |_( )/ _|_   _ 
+  / _` |/ _ \/ __| |/ /| |_| | | |
+ | (_| |  __/\__ \    <|  _| |_| |
+  \__,_|\___||___/_|\_\\_|  \__, |
+                            |___/ 
+   Web to Linux Desktop App Packager
+```
+
+---
+
+## 💡 The Problem
+
+Running websites as desktop applications in Linux is fantastic for productivity, but doing it manually via Electron or Nativefier involves a tedious and repetitive sequence:
+1. **Compiling**: Running complex CLI arguments for resolution, persisting sessions, and restricting domains.
+2. **Permissions Fix**: Electron applications on modern Linux distros fail to start unless the `chrome-sandbox` file is owned by root and given `4755` setuid permissions (due to kernel user-namespace changes).
+3. **Shortcut Integration**: Manually writing `.desktop` launch files inside `~/.local/share/applications/` and resolving icons.
+4. **The Dash Icon Bug (`StartupWMClass`)**: Nativefier appends a dynamic 6-character hash (e.g. `nextcloud-nativefier-a8e93f`) to the Electron window class (`WM_CLASS`) on compile. If your `.desktop` launcher has an outdated hash, **your launcher icon breaks in the Dash/Dock** (showing a generic gear icon or a duplicate unpinned icon).
+
+**Deskify solves all of these pains automatically in one prompt-driven wizard.**
+
+---
+
+## ✨ Features
+
+- 🖥️ **Interactive Wizard**: No command arguments to memorize. Simply type `deskify` and follow the beautiful, colorized prompts.
+- 🔗 **Smart Defaults**: Enter any URL (e.g., `https://panggon.danyakmallun.dev`) and Deskify will automatically extract the app name, domain, and set up domain boundary regexes (`.*panggon\.danyakmallun\.dev.*`) so links inside the app stay inside, and outside links open in your default browser.
+- 🎨 **Favicon Auto-Downloader**: Automatically downloads and configures the highest quality favicon from Google APIs to use as the app launcher icon.
+- 🔑 **Auto-Sandbox Permission Fix**: Automatically runs `sudo chown root:root` and `sudo chmod 4755` on `chrome-sandbox` inside the interactive terminal, ensuring the app boots successfully.
+- 🎯 **Dynamic StartupWMClass Tracking**: Automatically parses the generated `package.json` inside the Electron source code, extracts the unique Nativefier build hash, and writes the correct `StartupWMClass` to ensure application launcher matching in your system app menu and dock.
+- 📦 **App Directory Organization**: Moves the generated packages out of your home directory and places them inside a clean `~/Apps` folder (or custom directory).
+- ⚡ **Zero-Dependency**: Written purely in native Node.js API. No `node_modules` required to download or run.
+
+---
+
+## 🚀 Quick Start
+
+### 1. Requirements
+
+Ensure you have Node.js and NPM installed on your Linux system. Deskify checks for these on boot.
+On Ubuntu/Debian/Mint:
+```bash
+sudo apt update && sudo apt install -y nodejs npm
+```
+
+### 2. Running Deskify
+
+You don't even need to install Deskify to try it! Run it directly using `npx`:
+```bash
+npx https://github.com/<your-username>/deskify
+```
+*(Or run it locally if you cloned the repository)*:
+```bash
+node deskify.js
+```
+
+### 3. Global Installation (Optional)
+
+Install it globally using NPM so you can call `deskify` anywhere in your terminal:
+```bash
+npm install -g .
+```
+
+---
+
+## 🛠️ How It Works
+
+```mermaid
+graph TD
+    A[User Types URL & Name] --> B[Pre-flight Check: Node/NPM/Apt]
+    B --> C[Auto-download High-Res Favicon]
+    C --> D[Compile Webapp via Nativefier]
+    D --> E[Move app package to ~/Apps/]
+    E --> F[Parse generated package.json for Name & Hash]
+    F --> G[Reconstruct exact StartupWMClass]
+    G --> H[Run Sudo chmod/chown on chrome-sandbox]
+    H --> I[Generate ~/.local/share/applications/App.desktop]
+    I --> J[Run update-desktop-database]
+    J --> K[App appears in System Search & Dock with proper icon!]
+```
+
+---
+
+## 📄 License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

package/deskify.js

@@ -0,0 +1,1001 @@
+#!/usr/bin/env node
+
+/**
+ * deskify.js
+ * An interactive, zero-dependency CLI tool to turn web pages into Linux desktop applications using Nativefier.
+ * Author: Antigravity AI
+ * License: MIT
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const https = require('https');
+const { execSync, spawn } = require('child_process');
+const readline = require('readline');
+
+// ANSI escape codes for styling
+const colors = {
+  reset: '\x1b[0m',
+  bright: '\x1b[1m',
+  dim: '\x1b[2m',
+  underline: '\x1b[4m',
+  blink: '\x1b[5m',
+  reverse: '\x1b[7m',
+  hidden: '\x1b[8m',
+  
+  black: '\x1b[30m',
+  red: '\x1b[31m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+  magenta: '\x1b[35m',
+  cyan: '\x1b[36m',
+  white: '\x1b[37m',
+  
+  bgBlack: '\x1b[40m',
+  bgRed: '\x1b[41m',
+  bgGreen: '\x1b[42m',
+  bgYellow: '\x1b[43m',
+  bgBlue: '\x1b[44m',
+  bgMagenta: '\x1b[45m',
+  bgCyan: '\x1b[46m',
+  bgWhite: '\x1b[47m'
+};
+
+// Console output helpers
+const log = {
+  info: (msg) => console.log(`${colors.cyan}info:${colors.reset} ${msg}`),
+  success: (msg) => console.log(`${colors.green}success:${colors.reset} ${colors.bright}${msg}${colors.reset}`),
+  warn: (msg) => console.log(`${colors.yellow}warning:${colors.reset} ${msg}`),
+  error: (msg) => console.error(`${colors.red}error:${colors.reset} ${colors.bright}${msg}${colors.reset}`),
+  bold: (msg) => console.log(`${colors.bright}${msg}${colors.reset}`),
+  accent: (msg) => console.log(`${colors.magenta}${msg}${colors.reset}`)
+};
+
+// Help helper to expand tilde in paths
+function expandHome(pathStr) {
+  if (!pathStr) return '';
+  if (pathStr.startsWith('~/') || pathStr === '~') {
+    return pathStr.replace('~', os.homedir());
+  }
+  return pathStr;
+}
+
+// Helper to ask a question via raw-keypress to capture the Escape (ESC) key
+function ask(questionText, defaultValue = '') {
+  return new Promise((resolve, reject) => {
+    const prompt = defaultValue 
+      ? `${colors.bright}${questionText}${colors.reset} ${colors.dim}(default: ${defaultValue})${colors.reset}: `
+      : `${colors.bright}${questionText}${colors.reset}: `;
+      
+    process.stdout.write(prompt);
+    
+    let buffer = '';
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    
+    // Enable raw keypress listening
+    readline.emitKeypressEvents(process.stdin, rl);
+    if (process.stdin.isTTY) {
+      process.stdin.setRawMode(true);
+    }
+    
+    function onKeypress(str, key) {
+      if (key) {
+        if (key.name === 'escape') {
+          cleanup();
+          reject(new Error('ESC'));
+          return;
+        }
+        if (key.ctrl && key.name === 'c') {
+          cleanup();
+          process.stdout.write('\n');
+          process.exit(0);
+        }
+        if (key.name === 'return' || key.name === 'enter') {
+          cleanup();
+          process.stdout.write('\n');
+          resolve(buffer.trim() || defaultValue);
+          return;
+        }
+        if (key.name === 'backspace') {
+          if (buffer.length > 0) {
+            buffer = buffer.slice(0, -1);
+            // Clear line and redraw prompt + buffer
+            process.stdout.write('\r\x1B[2K');
+            process.stdout.write(prompt + buffer);
+          }
+          return;
+        }
+      }
+      
+      // Write standard character
+      if (str && str.length === 1 && !key.ctrl && !key.meta) {
+        buffer += str;
+        process.stdout.write(str);
+      }
+    }
+    
+    function cleanup() {
+      process.stdin.removeListener('keypress', onKeypress);
+      if (process.stdin.isTTY) {
+        process.stdin.setRawMode(false);
+      }
+      rl.close();
+    }
+    
+    process.stdin.on('keypress', onKeypress);
+  });
+}
+
+// Helper to ask a yes/no question
+async function askYesNo(questionText, defaultYes = true) {
+  const defaultStr = defaultYes ? 'Y/n' : 'y/N';
+  const answer = await ask(`${questionText} (${defaultStr})`);
+  if (!answer) return defaultYes;
+  return answer.toLowerCase().startsWith('y');
+}
+
+// Helper for arrow-key interactive selection menu (zero-dependency)
+function selectOption(questionText, options, defaultIndex = 0) {
+  return new Promise((resolve) => {
+    let selectedIndex = defaultIndex;
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    
+    // Enable raw keypress listening
+    readline.emitKeypressEvents(process.stdin, rl);
+    if (process.stdin.isTTY) {
+      process.stdin.setRawMode(true);
+    }
+    
+    // Hide standard cursor
+    process.stdout.write('\x1B[?25l');
+
+    function renderMenu() {
+      console.log(`\n${colors.bright}${colors.cyan}❯${colors.reset} ${colors.bright}${questionText}${colors.reset}`);
+      options.forEach((opt, idx) => {
+        if (idx === selectedIndex) {
+          console.log(`  ${colors.cyan}${colors.bright}❯ ${opt}${colors.reset}`);
+        } else {
+          console.log(`    ${colors.dim}${opt}${colors.reset}`);
+        }
+      });
+    }
+
+    renderMenu();
+
+    function onKeypress(str, key) {
+      // Move cursor back up options.length + 2 lines and clear them
+      const linesToMove = options.length + 2;
+      process.stdout.write(`\x1B[${linesToMove}A`);
+      for (let i = 0; i < linesToMove; i++) {
+        process.stdout.write('\x1B[2K\n');
+      }
+      process.stdout.write(`\x1B[${linesToMove}A`);
+
+      if (key) {
+        if (key.name === 'up') {
+          selectedIndex = (selectedIndex - 1 + options.length) % options.length;
+        } else if (key.name === 'down') {
+          selectedIndex = (selectedIndex + 1) % options.length;
+        } else if (key.name === 'return' || key.name === 'enter') {
+          cleanup();
+          resolve(selectedIndex);
+          return;
+        } else if (key.name === 'escape') {
+          cleanup();
+          resolve(options.length - 1); // select the last option (Cancel/Exit)
+          return;
+        } else if (key.ctrl && key.name === 'c') {
+          cleanup();
+          process.stdout.write('\n');
+          process.exit(0);
+        }
+      }
+      renderMenu();
+    }
+
+    function cleanup() {
+      process.stdin.removeListener('keypress', onKeypress);
+      if (process.stdin.isTTY) {
+        process.stdin.setRawMode(false);
+      }
+      // Show cursor again
+      process.stdout.write('\x1B[?25h');
+      rl.close();
+      
+      // Clear the menu before resolving so the console is kept clean
+      const linesToMove = options.length + 2;
+      process.stdout.write(`\x1B[${linesToMove}A`);
+      for (let i = 0; i < linesToMove; i++) {
+        process.stdout.write('\x1B[2K\n');
+      }
+      process.stdout.write(`\x1B[${linesToMove}A`);
+    }
+
+    process.stdin.on('keypress', onKeypress);
+  });
+}
+
+// Spinner variables and functions
+let spinnerInterval = null;
+function startSpinner(msg) {
+  const frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+  let i = 0;
+  // Hide cursor
+  process.stdout.write('\x1B[?25l');
+  process.stdout.write(`${colors.cyan}${frames[0]}${colors.reset} ${msg}`);
+  spinnerInterval = setInterval(() => {
+    i = (i + 1) % frames.length;
+    process.stdout.write(`\r${colors.cyan}${frames[i]}${colors.reset} ${msg}`);
+  }, 80);
+}
+
+function stopSpinner(success = true, statusMsg = '') {
+  if (spinnerInterval) {
+    clearInterval(spinnerInterval);
+    spinnerInterval = null;
+  }
+  // Clear the spinner line
+  process.stdout.write('\r\x1B[2K');
+  // Show cursor
+  process.stdout.write('\x1B[?25h');
+  
+  if (statusMsg) {
+    if (success) {
+      console.log(`${colors.green}✔${colors.reset} ${statusMsg}`);
+    } else {
+      console.log(`${colors.red}✖${colors.reset} ${statusMsg}`);
+    }
+  }
+}
+
+// Extract domain and subdomains for smart defaults
+function parseUrlDetails(urlStr) {
+  try {
+    // Add protocol if missing for URL parsing
+    let cleanUrl = urlStr;
+    if (!/^https?:\/\//i.test(urlStr)) {
+      cleanUrl = 'https://' + urlStr;
+    }
+    const parsed = new URL(cleanUrl);
+    const hostname = parsed.hostname;
+    
+    // Extract a nice default app name (first segment of domain, e.g. panggon.danyakmallun.dev -> Panggon)
+    const segments = hostname.split('.');
+    let nameDefault = 'Webapp';
+    if (segments.length > 0) {
+      const firstSegment = segments[0] === 'www' && segments.length > 1 ? segments[1] : segments[0];
+      nameDefault = firstSegment.charAt(0).toUpperCase() + firstSegment.slice(1);
+    }
+
+    // Escape dots for regex
+    const escapedDomain = hostname.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const regexDefault = `.*${escapedDomain}.*`;
+
+    return {
+      cleanUrl,
+      hostname,
+      nameDefault,
+      regexDefault
+    };
+  } catch (e) {
+    return {
+      cleanUrl: urlStr,
+      hostname: '',
+      nameDefault: 'Webapp',
+      regexDefault: '.*'
+    };
+  }
+}
+
+// Helper to download a file from a URL, following redirects
+function downloadUrl(urlStr, outputPath, redirectCount = 0) {
+  return new Promise((resolve) => {
+    if (redirectCount > 5) {
+      resolve(false); // prevent infinite redirect loops
+      return;
+    }
+    
+    try {
+      https.get(urlStr, (response) => {
+        // Handle redirects (301, 302, 307, 308)
+        if ([301, 302, 307, 308].includes(response.statusCode) && response.headers.location) {
+          let redirectUrl = response.headers.location;
+          // Resolve relative redirects
+          if (redirectUrl.startsWith('/')) {
+            const parsed = new URL(urlStr);
+            redirectUrl = `${parsed.protocol}//${parsed.host}${redirectUrl}`;
+          }
+          resolve(downloadUrl(redirectUrl, outputPath, redirectCount + 1));
+          return;
+        }
+
+        if (response.statusCode === 200) {
+          const file = fs.createWriteStream(outputPath);
+          response.pipe(file);
+          file.on('finish', () => {
+            file.close();
+            resolve(true);
+          });
+        } else {
+          resolve(false);
+        }
+      }).on('error', () => {
+        resolve(false);
+      });
+    } catch (e) {
+      resolve(false);
+    }
+  });
+}
+
+// Helper to fetch HTML content of a URL, following redirects
+function getHtml(urlStr, redirectCount = 0) {
+  return new Promise((resolve) => {
+    if (redirectCount > 5) {
+      resolve('');
+      return;
+    }
+
+    try {
+      https.get(urlStr, (response) => {
+        if ([301, 302, 307, 308].includes(response.statusCode) && response.headers.location) {
+          let redirectUrl = response.headers.location;
+          if (redirectUrl.startsWith('/')) {
+            const parsed = new URL(urlStr);
+            redirectUrl = `${parsed.protocol}//${parsed.host}${redirectUrl}`;
+          }
+          resolve(getHtml(redirectUrl, redirectCount + 1));
+          return;
+        }
+        
+        if (response.statusCode !== 200) {
+          resolve('');
+          return;
+        }
+        
+        let data = '';
+        response.on('data', chunk => { data += chunk; });
+        response.on('end', () => { resolve(data); });
+      }).on('error', () => {
+        resolve('');
+      });
+    } catch (e) {
+      resolve('');
+    }
+  });
+}
+
+// Helper to extract absolute icon URL from HTML
+function extractIconUrl(html, baseUrl) {
+  // Look for rel="icon", rel="shortcut icon", or rel="apple-touch-icon"
+  const matches = html.match(/<link[^>]*rel=["'](icon|shortcut icon|apple-touch-icon)["'][^>]*>/gi);
+  if (matches) {
+    for (const link of matches) {
+      const hrefMatch = link.match(/href=["']([^"']+)["']/i);
+      if (hrefMatch) {
+        let href = hrefMatch[1];
+        // Resolve absolute URL
+        if (!/^https?:\/\//i.test(href)) {
+          try {
+            const parsed = new URL(baseUrl);
+            if (href.startsWith('//')) {
+              href = parsed.protocol + href;
+            } else if (href.startsWith('/')) {
+              href = `${parsed.protocol}//${parsed.host}${href}`;
+            } else {
+              const pathname = parsed.pathname.endsWith('/') ? parsed.pathname : path.dirname(parsed.pathname) + '/';
+              href = `${parsed.protocol}//${parsed.host}${pathname}${href}`;
+            }
+          } catch (e) {
+            continue;
+          }
+        }
+        return href;
+      }
+    }
+  }
+  return null;
+}
+
+// Dynamic favicon downloader flow supporting Google API, direct scraping, and default fallback
+async function downloadFaviconFlow(targetUrl, domain, outputPath) {
+  startSpinner('Fetching website favicon...');
+  // 1. Try Google Favicon Service (follows redirects)
+  const googleUrl = `https://www.google.com/s2/favicons?sz=128&domain=${domain}`;
+  let success = await downloadUrl(googleUrl, outputPath);
+  if (success) {
+    // Verify it didn't download a tiny 1x1 default spacer/404 image (file size less than 1KB)
+    try {
+      const stats = fs.statSync(outputPath);
+      if (stats.size > 1000) {
+        stopSpinner(true, 'Favicon downloaded successfully!');
+        return true; 
+      }
+      fs.unlinkSync(outputPath); // Delete generic tiny favicon
+    } catch (e) {}
+  }
+
+  // 2. Try scraping target URL directly (great for local/private servers)
+  try {
+    const html = await getHtml(targetUrl);
+    if (html) {
+      const iconUrl = extractIconUrl(html, targetUrl);
+      if (iconUrl) {
+        success = await downloadUrl(iconUrl, outputPath);
+        if (success) {
+          stopSpinner(true, 'Favicon scraped and downloaded successfully!');
+          return true;
+        }
+      }
+    }
+  } catch (e) {
+    // Ignore scraper errors
+  }
+
+  // 3. Try default fallback path: https://domain/favicon.ico
+  try {
+    const parsed = new URL(targetUrl);
+    const fallbackUrl = `${parsed.protocol}//${parsed.host}/favicon.ico`;
+    success = await downloadUrl(fallbackUrl, outputPath);
+    if (success) {
+      stopSpinner(true, 'Default favicon.ico downloaded successfully!');
+      return true;
+    }
+  } catch (e) {
+    // Ignore fallback errors
+  }
+
+  stopSpinner(false, 'Could not download favicon. Fallback to default Electron icon.');
+  return false;
+}
+
+// Print startup header
+function printHeader() {
+  console.clear();
+  console.log(`${colors.cyan}${colors.bright}`);
+  console.log(`      _           _   _  __       `);
+  console.log(`   __| | ___  ___| |_( )/ _|_   _ `);
+  console.log(`  / _\` |/ _ \\/ __| |/ /| |_| | | |`);
+  console.log(` | (_| |  __/\\__ \\    <|  _| |_| |`);
+  console.log(`  \\__,_|\\___||___/_|\\_\\\\_|  \\__, |`);
+  console.log(`                            |___/ `);
+  console.log(`   Web to Linux Desktop App Packager${colors.reset}`);
+  console.log(`${colors.dim}--------------------------------------------------${colors.reset}\n`);
+}
+
+// Verification checks
+function runPreflightChecks() {
+  startSpinner('Running system pre-flight checks...');
+  
+  // 1. Check Node.js
+  try {
+    execSync('node -v', { stdio: 'ignore' });
+  } catch (e) {
+    stopSpinner(false, 'Pre-flight checks failed.');
+    log.error('Node.js is not installed or not in PATH.');
+    process.exit(1);
+  }
+
+  // 2. Check NPM
+  try {
+    execSync('npm -v', { stdio: 'ignore' });
+  } catch (e) {
+    stopSpinner(false, 'Pre-flight checks failed.');
+    log.error('NPM is not installed or not in PATH.');
+    process.exit(1);
+  }
+
+  // 3. Check update-desktop-database
+  let hasDesktopUtils = true;
+  try {
+    execSync('command -v update-desktop-database', { stdio: 'ignore' });
+  } catch (e) {
+    hasDesktopUtils = false;
+  }
+
+  stopSpinner(true, 'Pre-flight checks passed successfully!\n');
+  if (!hasDesktopUtils) {
+    log.warn('update-desktop-database not found. Shortcuts might not register instantly.');
+  }
+  return { hasDesktopUtils };
+}
+
+// Core creation flow (formerly main)
+async function createFlow(hasDesktopUtils) {
+  console.clear();
+  printHeader();
+  log.bold('--- Create a New Desktop Application ---');
+  console.log('');
+
+  // Variables declared outside block for subsequent Nativefier compilation
+  let targetUrl = '';
+  let appName = '';
+  let iconPath = '';
+  let persistSession = true;
+  let internalUrlsRegex = '';
+  let width = '1200';
+  let height = '800';
+  let installPath = '';
+
+  try {
+    // 1. Prompt for URL
+    let targetUrlInput = '';
+    while (!targetUrlInput) {
+      targetUrlInput = await ask('Enter Website URL (e.g., https://nextcloud.com)');
+      if (!targetUrlInput) {
+        log.error('URL cannot be empty. Please try again.');
+      }
+    }
+
+    // Parse details for defaults
+    const urlDetails = parseUrlDetails(targetUrlInput);
+    targetUrl = urlDetails.cleanUrl;
+    
+    log.info(`Parsed Target URL: ${colors.bright}${targetUrl}${colors.reset}`);
+
+    // 2. Prompt for Name
+    appName = await ask('Enter Application Name', urlDetails.nameDefault);
+
+    // 3. Prompt for Icon
+    const useFavicon = await askYesNo('Download and use website favicon as app icon?', true);
+    
+    if (useFavicon) {
+      const tempIconDir = path.join(os.tmpdir(), 'deskify');
+      if (!fs.existsSync(tempIconDir)) {
+        fs.mkdirSync(tempIconDir, { recursive: true });
+      }
+      const tempIconPath = path.join(tempIconDir, `${appName.toLowerCase()}_favicon.png`);
+      
+      const success = await downloadFaviconFlow(targetUrl, urlDetails.hostname, tempIconPath);
+      
+      if (success) {
+        iconPath = tempIconPath;
+      }
+    } else {
+      const localIcon = await ask('Enter local PNG icon file path (leave empty for none)');
+      if (localIcon) {
+        const expandedIconPath = expandHome(localIcon);
+        if (fs.existsSync(expandedIconPath)) {
+          iconPath = expandedIconPath;
+        } else {
+          log.warn(`File "${localIcon}" not found. Fallback to default Electron icon.`);
+        }
+      }
+    }
+
+    // 4. Prompt for Persist option
+    persistSession = await askYesNo('Persist session cookies, local storage, and cache?', true);
+
+    // 5. Prompt for Internal URLs Regex
+    internalUrlsRegex = await ask('Internal URL pattern regex', urlDetails.regexDefault);
+
+    // 6. Window Dimensions
+    width = await ask('Window width (pixels)', '1200');
+    height = await ask('Window height (pixels)', '800');
+
+    // 7. Installation Path
+    const installPathInput = await ask('Installation directory', '~/Apps');
+    installPath = expandHome(installPathInput);
+
+    // Summary before execution
+    console.log(`\n${colors.bright}--- Build Configuration Summary ---${colors.reset}`);
+    console.log(`App Name:      ${colors.green}${appName}${colors.reset}`);
+    console.log(`Target URL:    ${targetUrl}`);
+    console.log(`Persist:       ${persistSession ? 'Yes' : 'No'}`);
+    console.log(`Internal URLs: ${internalUrlsRegex}`);
+    console.log(`Dimensions:    ${width}x${height}`);
+    console.log(`Install Dir:   ${installPath}`);
+    if (iconPath) {
+      console.log(`Icon Path:     ${iconPath}`);
+    }
+    console.log(`${colors.dim}------------------------------------${colors.reset}\n`);
+
+    const proceed = await askYesNo('Proceed with build?', true);
+    if (!proceed) {
+      log.warn('Build aborted by user.');
+      return { success: false, cancelled: true };
+    }
+  } catch (e) {
+    if (e.message === 'ESC') {
+      log.warn('\nBuild cancelled by user (ESC pressed). Returning to Main Menu...');
+      return { success: false, cancelled: true };
+    }
+    throw e;
+  }
+
+  // Ensure install path exists
+  if (!fs.existsSync(installPath)) {
+    log.info(`Creating installation directory: ${installPath}`);
+    fs.mkdirSync(installPath, { recursive: true });
+  }
+
+  // 8. Build using Nativefier
+  log.bold('\n[1/4] Running Nativefier compiler...');
+  
+  // Construct arguments matching Nativefier's positional syntax:
+  // nativefier <targetUrl> [outputDirectory] [options]
+  const args = [
+    'nativefier',
+    targetUrl,
+    installPath,
+    '--name', appName,
+    '--width', `${width}px`,
+    '--height', `${height}px`,
+    '--internal-urls', internalUrlsRegex
+  ];
+
+  if (persistSession) {
+    args.push('--persist');
+  }
+
+  if (iconPath) {
+    args.push('--icon', iconPath);
+  }
+
+  log.info(`Running command: npx ${args.join(' ')}`);
+
+  try {
+    // Run npx nativefier synchronously, streaming the output to the console
+    execSync(`npx -y ${args.map(a => `"${a}"`).join(' ')}`, { stdio: 'inherit' });
+    log.success('Nativefier compile completed!');
+  } catch (error) {
+    log.error('Nativefier failed to compile the application.');
+    console.error(error.message);
+    return { success: false };
+  }
+
+  // 9. Find generated directory
+  log.bold('\n[2/4] Locating generated application folder...');
+  
+  // Search for the folder in the install directory. Nativefier outputs folder names like Name-linux-x64
+  const files = fs.readdirSync(installPath);
+  // Find folder matching appname-linux-x64 (case insensitive search)
+  const targetDirName = files.find(f => {
+    const isDir = fs.statSync(path.join(installPath, f)).isDirectory();
+    return isDir && f.toLowerCase().includes('linux-x64') && f.toLowerCase().includes(appName.toLowerCase());
+  });
+
+  if (!targetDirName) {
+    log.error(`Could not locate the generated application directory in ${installPath}.`);
+    log.info(`Available folders: ${files.join(', ')}`);
+    return { success: false };
+  }
+
+  const appFolder = path.join(installPath, targetDirName);
+  log.success(`Located folder at: ${appFolder}`);
+
+  // Copy icon.png if we downloaded it and nativefier didn't put it in the root
+  const destIconPath = path.join(appFolder, 'icon.png');
+  if (iconPath && !fs.existsSync(destIconPath)) {
+    try {
+      fs.copyFileSync(iconPath, destIconPath);
+      log.info(`Copied application icon to: ${destIconPath}`);
+    } catch (e) {
+      log.warn(`Could not copy icon to root: ${e.message}`);
+    }
+  }
+
+  // Adjust permissions on the app directory and icon file to ensure GNOME can load them
+  try {
+    fs.chmodSync(appFolder, 0o755);
+    if (fs.existsSync(destIconPath)) {
+      fs.chmodSync(destIconPath, 0o644);
+      
+      // Auto-resize extremely large custom icons to 256x256 using convert (ImageMagick)
+      try {
+        execSync('command -v convert', { stdio: 'ignore' });
+        log.info('Optimizing icon resolution (resizing to 256x256)...');
+        execSync(`convert "${destIconPath}" -resize 256x256 "${destIconPath}"`, { stdio: 'ignore' });
+        log.success('Icon optimized and resized successfully!');
+      } catch (e) {
+        // Skip optimization if convert is not installed
+      }
+    }
+  } catch (e) {
+    log.warn(`Could not adjust permissions on folder/icon: ${e.message}`);
+  }
+
+  // 10. Dynamic StartupWMClass resolver by reading package.json
+  log.bold('\n[3/4] Resolving Linux window class (StartupWMClass)...');
+  
+  const pkgPath = path.join(appFolder, 'resources', 'app', 'package.json');
+  let startupWMClass = appName; // Default fallback
+  let packageJsonName = '';
+
+  if (fs.existsSync(pkgPath)) {
+    try {
+      const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+      packageJsonName = pkg.name; // e.g. nextcloud-nativefier-7cf0d6
+      log.info(`Found internal app ID in package.json: ${colors.bright}${packageJsonName}${colors.reset}`);
+      
+      // Use the exact packageJsonName directly since Electron's window class instance name on Linux
+      // always matches the lowercase 'name' field in package.json.
+      startupWMClass = packageJsonName;
+      log.success(`Calculated StartupWMClass: ${colors.bright}${startupWMClass}${colors.reset}`);
+    } catch (e) {
+      log.warn(`Could not parse internal package.json: ${e.message}. Using app name fallback.`);
+    }
+  } else {
+    log.warn('Could not find internal package.json. StartupWMClass might be inaccurate.');
+  }
+
+  // 11. Fix chrome-sandbox permissions via sudo
+  log.bold('\n[4/4] Setting up sandbox execution permissions (requires sudo)...');
+  const chromeSandboxPath = path.join(appFolder, 'chrome-sandbox');
+  
+  if (fs.existsSync(chromeSandboxPath)) {
+    log.info(`Applying root ownership and SUID bit to: ${chromeSandboxPath}`);
+    try {
+      // Execute permissions fix. stdio: 'inherit' displays password prompt nicely
+      execSync(`sudo chown root:root "${chromeSandboxPath}" && sudo chmod 4755 "${chromeSandboxPath}"`, { stdio: 'inherit' });
+      log.success('Sandbox permissions applied successfully!');
+    } catch (e) {
+      log.error('Failed to configure chrome-sandbox permissions.');
+      log.info('You may need to run this command manually:');
+      console.log(`  sudo chown root:root "${chromeSandboxPath}" && sudo chmod 4755 "${chromeSandboxPath}"`);
+    }
+  } else {
+    log.warn('chrome-sandbox file not found in build directory. Skipping permission adjustment.');
+  }
+
+  // 12. Create Desktop File
+  log.bold('\n[5/5] Generating Desktop Shortcut launcher...');
+  
+  const desktopEntriesDir = expandHome('~/.local/share/applications');
+  if (!fs.existsSync(desktopEntriesDir)) {
+    fs.mkdirSync(desktopEntriesDir, { recursive: true });
+  }
+
+  const desktopFilePath = path.join(desktopEntriesDir, `${appName.replace(/\s+/g, '')}.desktop`);
+  
+  // Locate binary executable (usually named after the AppName, case-sensitive)
+  const execPath = path.join(appFolder, appName);
+  // Locate icon path. Use root icon.png if exists, otherwise fallback to app folder
+  const finalIconPath = fs.existsSync(destIconPath) ? destIconPath : (iconPath || 'electron');
+
+  const desktopContent = `[Desktop Entry]
+Name=${appName}
+Comment=${appName} Web Desktop App
+Exec=${execPath}
+Icon=${finalIconPath}
+Terminal=false
+Type=Application
+Categories=Network;WebBrowser;Application;
+StartupWMClass=${startupWMClass}
+X-Generated-By=deskify
+`;
+
+  try {
+    fs.writeFileSync(desktopFilePath, desktopContent, 'utf8');
+    fs.chmodSync(desktopFilePath, 0o755); // make executable
+    log.success(`Shortcut created successfully at: ${desktopFilePath}`);
+
+    // Update desktop registry database
+    if (hasDesktopUtils) {
+      log.info('Updating local desktop shortcut registry database...');
+      execSync(`update-desktop-database "${desktopEntriesDir}"`, { stdio: 'ignore' });
+      log.success('Desktop shortcuts database updated!');
+    }
+  } catch (e) {
+    log.error(`Failed to write desktop launcher: ${e.message}`);
+  }
+
+  // Clean up temporary icons if any
+  if (useFavicon && iconPath && fs.existsSync(iconPath)) {
+    try {
+      fs.unlinkSync(iconPath);
+    } catch (e) {}
+  }
+
+  // Success summary
+  console.log(`\n${colors.green}${colors.bright}==================================================${colors.reset}`);
+  console.log(`${colors.green}${colors.bright} 🎉 CONGRATULATIONS! APP CREATED SUCCESSFULLY 🎉${colors.reset}`);
+  console.log(`${colors.green}${colors.bright}==================================================${colors.reset}`);
+  console.log(`App Name:      ${colors.bright}${appName}${colors.reset}`);
+  console.log(`Folder Path:   ${colors.cyan}${appFolder}${colors.reset}`);
+  console.log(`Shortcut Path: ${colors.cyan}${desktopFilePath}${colors.reset}`);
+  console.log(`WM_Class ID:   ${colors.magenta}${startupWMClass}${colors.reset}`);
+  console.log(`\nYou can now search for "${appName}" in your Linux App menu! 🚀\n`);
+  return { success: true };
+}
+
+// Interactive Uninstallation flow
+async function uninstallFlow(hasDesktopUtils) {
+  console.clear();
+  printHeader();
+  log.bold('--- Uninstall an Existing Application ---');
+  console.log('');
+  const desktopEntriesDir = expandHome('~/.local/share/applications');
+  
+  if (!fs.existsSync(desktopEntriesDir)) {
+    log.warn('No local application shortcuts directory found.');
+    return { success: false };
+  }
+
+  const files = fs.readdirSync(desktopEntriesDir);
+  const deskifyApps = [];
+
+  for (const file of files) {
+    if (file.endsWith('.desktop')) {
+      const filePath = path.join(desktopEntriesDir, file);
+      try {
+        const content = fs.readFileSync(filePath, 'utf8');
+        if (content.includes('X-Generated-By=deskify')) {
+          // Parse metadata
+          const nameMatch = content.match(/^Name=(.+)$/m);
+          const execMatch = content.match(/^Exec=(.+)$/m);
+          const appName = nameMatch ? nameMatch[1].trim() : file.replace('.desktop', '');
+          let execPath = execMatch ? execMatch[1].trim() : '';
+          
+          // Strip wrapping quotes from Exec path if present
+          if (execPath.startsWith('"') && execPath.endsWith('"')) {
+            execPath = execPath.slice(1, -1);
+          }
+
+          let appFolder = '';
+          if (execPath) {
+            appFolder = path.dirname(execPath);
+          }
+
+          deskifyApps.push({
+            file,
+            filePath,
+            appName,
+            appFolder
+          });
+        }
+      } catch (e) {
+        // Skip files that can't be read
+      }
+    }
+  }
+
+  if (deskifyApps.length === 0) {
+    log.info('No applications generated by deskify were found.');
+    return { success: false };
+  }
+
+  const appOptions = deskifyApps.map(app => `${app.appName} ${colors.dim}(Shortcut: ${app.file})${colors.reset}`);
+  appOptions.push('Cancel');
+
+  const selectedIdx = await selectOption('Select an application to uninstall', appOptions, appOptions.length - 1);
+  
+  if (selectedIdx === appOptions.length - 1) {
+    log.info('Uninstallation cancelled.');
+    return { success: false, cancelled: true };
+  }
+
+  const targetApp = deskifyApps[selectedIdx];
+  
+  log.warn(`\nAre you sure you want to permanently delete ${colors.red}${targetApp.appName}${colors.reset}?`);
+  log.warn(`This will delete:`);
+  log.warn(`  - Shortcut:  ${targetApp.filePath}`);
+  if (targetApp.appFolder && fs.existsSync(targetApp.appFolder)) {
+    log.warn(`  - App Folder: ${targetApp.appFolder}`);
+  }
+  console.log('');
+
+  try {
+    const confirm = await askYesNo('Confirm uninstallation?', false);
+    if (!confirm) {
+      log.info('Uninstallation cancelled.');
+      return { success: false, cancelled: true };
+    }
+  } catch (e) {
+    if (e.message === 'ESC') {
+      log.warn('\nUninstallation cancelled by user (ESC pressed). Returning to Main Menu...');
+      return { success: false, cancelled: true };
+    }
+    throw e;
+  }
+
+  // 1. Delete .desktop entry file
+  try {
+    if (fs.existsSync(targetApp.filePath)) {
+      fs.unlinkSync(targetApp.filePath);
+      log.success(`Deleted shortcut file: ${targetApp.file}`);
+    }
+  } catch (e) {
+    log.error(`Failed to delete shortcut file: ${e.message}`);
+  }
+
+  // 2. Delete the application installation directory recursively
+  if (targetApp.appFolder && fs.existsSync(targetApp.appFolder)) {
+    log.info(`Deleting application files at: ${targetApp.appFolder}...`);
+    try {
+      fs.rmSync(targetApp.appFolder, { recursive: true, force: true });
+      log.success('Application directory deleted successfully!');
+    } catch (e) {
+      log.error(`Failed to delete directory: ${e.message}`);
+      log.info('You may need to run this command manually as root/sudo:');
+      console.log(`  sudo rm -rf "${targetApp.appFolder}"`);
+    }
+  }
+
+  // 3. Update local desktop registry database
+  if (hasDesktopUtils) {
+    log.info('Updating desktop shortcuts registry database...');
+    try {
+      execSync(`update-desktop-database "${desktopEntriesDir}"`, { stdio: 'ignore' });
+      log.success('Desktop shortcuts database updated!');
+    } catch (e) {}
+  }
+
+  log.success(`\n🎉 ${targetApp.appName} has been uninstalled successfully! 🗑️\n`);
+  return { success: true };
+}
+
+// Helper to wait for enter key, allowing ESC to also go back
+async function waitForKey() {
+  try {
+    await ask('Press Enter to return to the Main Menu...');
+  } catch (e) {
+    // Silently consume ESC or any other rejection to return to main menu
+  }
+}
+
+// Main execution function
+async function main() {
+  while (true) {
+    printHeader();
+    const { hasDesktopUtils } = runPreflightChecks();
+
+    const options = [
+      'Create a new Desktop App',
+      'Uninstall an existing App',
+      'Exit'
+    ];
+
+    const selectedIdx = await selectOption('Deskify Main Menu', options, 0);
+    
+    if (selectedIdx === 0) {
+      try {
+        const result = await createFlow(hasDesktopUtils);
+        if (result && result.success) {
+          await waitForKey();
+        } else if (result && result.cancelled) {
+          // Do not wait, return directly to main menu
+        } else {
+          await waitForKey();
+        }
+      } catch (e) {
+        log.error('An error occurred during application creation:');
+        console.error(e);
+        await waitForKey();
+      }
+    } else if (selectedIdx === 1) {
+      try {
+        const result = await uninstallFlow(hasDesktopUtils);
+        if (result && result.success) {
+          await waitForKey();
+        } else if (result && result.cancelled) {
+          // Do not wait, return directly to main menu
+        } else {
+          await waitForKey();
+        }
+      } catch (e) {
+        log.error('An error occurred during application uninstallation:');
+        console.error(e);
+        await waitForKey();
+      }
+    } else if (selectedIdx === 2) {
+      log.info('Thank you for using Deskify! Goodbye! 👋');
+      process.exit(0);
+    }
+  }
+}
+
+// Run main program
+main().catch((err) => {
+  log.error('An unexpected error occurred during execution:');
+  console.error(err);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "deskify-cli",
+  "version": "1.0.0",
+  "description": "An interactive, zero-dependency CLI tool to turn web pages into Linux desktop applications using Nativefier.",
+  "main": "deskify.js",
+  "bin": {
+    "deskify": "./deskify.js"
+  },
+  "scripts": {
+    "start": "node deskify.js"
+  },
+  "keywords": [
+    "nativefier",
+    "linux",
+    "desktop-entry",
+    "electron",
+    "cli",
+    "automation",
+    "shortcut"
+  ],
+  "author": "",
+  "license": "MIT",
+  "engines": {
+    "node": ">=14.0.0"
+  }
+}