deskify-cli 1.0.0 → 1.0.2

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "deskify-cli",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "An interactive, zero-dependency CLI tool to turn web pages into Linux desktop applications using Nativefier.",
   "main": "deskify.js",
   "bin": {
-    "deskify": "./deskify.js"
+    "deskify": "deskify.js"
   },
   "scripts": {
     "start": "node deskify.js"

package/src/flows/create.js

@@ -0,0 +1,284 @@
+/**
+ * create.js
+ * Application packaging build flow for the deskify CLI.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { execSync } = require('child_process');
+const { colors, log } = require('../utils/colors');
+const { expandHome, ask, askYesNo } = require('../utils/prompts');
+const { parseUrlDetails, downloadFaviconFlow } = require('../utils/favicon');
+
+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`);
+}
+
+async function createFlow(hasDesktopUtils) {
+  console.clear();
+  printHeader();
+  log.bold('--- Create a New Desktop Application ---');
+  console.log('');
+
+  let targetUrl = '';
+  let appName = '';
+  let iconPath = '';
+  let persistSession = true;
+  let internalUrlsRegex = '';
+  let width = '1200';
+  let height = '800';
+  let installPath = '';
+
+  try {
+    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.');
+      }
+    }
+
+    const urlDetails = parseUrlDetails(targetUrlInput);
+    targetUrl = urlDetails.cleanUrl;
+    
+    log.info(`Parsed Target URL: ${colors.bright}${targetUrl}${colors.reset}`);
+
+    appName = await ask('Enter Application Name', urlDetails.nameDefault);
+
+    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.`);
+        }
+      }
+    }
+
+    persistSession = await askYesNo('Persist session cookies, local storage, and cache?', true);
+    internalUrlsRegex = await ask('Internal URL pattern regex', urlDetails.regexDefault);
+    width = await ask('Window width (pixels)', '1200');
+    height = await ask('Window height (pixels)', '800');
+
+    const installPathInput = await ask('Installation directory', '~/Apps');
+    installPath = expandHome(installPathInput);
+
+    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;
+  }
+
+  if (!fs.existsSync(installPath)) {
+    log.info(`Creating installation directory: ${installPath}`);
+    fs.mkdirSync(installPath, { recursive: true });
+  }
+
+  log.bold('\n[1/4] Running Nativefier compiler...');
+  
+  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 {
+    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 };
+  }
+
+  log.bold('\n[2/4] Locating generated application folder...');
+  const files = fs.readdirSync(installPath);
+  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}`);
+
+  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}`);
+    }
+  }
+
+  try {
+    fs.chmodSync(appFolder, 0o755);
+    if (fs.existsSync(destIconPath)) {
+      fs.chmodSync(destIconPath, 0o644);
+      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) {}
+    }
+  } catch (e) {
+    log.warn(`Could not adjust permissions on folder/icon: ${e.message}`);
+  }
+
+  log.bold('\n[3/4] Resolving Linux window class (StartupWMClass)...');
+  const pkgPath = path.join(appFolder, 'resources', 'app', 'package.json');
+  let startupWMClass = appName;
+  let packageJsonName = '';
+
+  if (fs.existsSync(pkgPath)) {
+    try {
+      const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+      packageJsonName = pkg.name;
+      log.info(`Found internal app ID in package.json: ${colors.bright}${packageJsonName}${colors.reset}`);
+      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.');
+  }
+
+  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 {
+      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.');
+  }
+
+  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`);
+  const execPath = path.join(appFolder, appName);
+  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);
+    log.success(`Shortcut created successfully at: ${desktopFilePath}`);
+
+    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}`);
+  }
+
+  if (useFavicon && iconPath && fs.existsSync(iconPath)) {
+    try {
+      fs.unlinkSync(iconPath);
+    } catch (e) {}
+  }
+
+  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 };
+}
+
+module.exports = {
+  createFlow
+};

package/src/flows/uninstall.js

@@ -0,0 +1,145 @@
+/**
+ * uninstall.js
+ * Application uninstallation flow for the deskify CLI.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+const { colors, log } = require('../utils/colors');
+const { expandHome, selectOption, askYesNo } = require('../utils/prompts');
+
+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`);
+}
+
+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')) {
+          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() : '';
+          
+          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) {}
+    }
+  }
+
+  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;
+  }
+
+  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}`);
+  }
+
+  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}"`);
+    }
+  }
+
+  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 };
+}
+
+module.exports = {
+  uninstallFlow
+};

package/src/utils/colors.js

@@ -0,0 +1,46 @@
+/**
+ * colors.js
+ * Formatting tokens and utility outputs for the deskify CLI.
+ */
+
+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'
+};
+
+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}`)
+};
+
+module.exports = {
+  colors,
+  log
+};

package/src/utils/favicon.js

@@ -0,0 +1,196 @@
+/**
+ * favicon.js
+ * Scrapes and downloads high-quality favicons for the deskify CLI.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const https = require('https');
+const { colors } = require('./colors');
+const { startSpinner, stopSpinner } = require('./spinner');
+
+function parseUrlDetails(urlStr) {
+  try {
+    let cleanUrl = urlStr;
+    if (!/^https?:\/\//i.test(urlStr)) {
+      cleanUrl = 'https://' + urlStr;
+    }
+    const parsed = new URL(cleanUrl);
+    const hostname = parsed.hostname;
+    
+    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);
+    }
+
+    const escapedDomain = hostname.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const regexDefault = `.*${escapedDomain}.*`;
+
+    return {
+      cleanUrl,
+      hostname,
+      nameDefault,
+      regexDefault
+    };
+  } catch (e) {
+    return {
+      cleanUrl: urlStr,
+      hostname: '',
+      nameDefault: 'Webapp',
+      regexDefault: '.*'
+    };
+  }
+}
+
+function downloadUrl(urlStr, outputPath, redirectCount = 0) {
+  return new Promise((resolve) => {
+    if (redirectCount > 5) {
+      resolve(false);
+      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(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);
+    }
+  });
+}
+
+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('');
+    }
+  });
+}
+
+function extractIconUrl(html, baseUrl) {
+  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];
+        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;
+}
+
+async function downloadFaviconFlow(targetUrl, domain, outputPath) {
+  startSpinner('Fetching website favicon...');
+  const googleUrl = `https://www.google.com/s2/favicons?sz=128&domain=${domain}`;
+  let success = await downloadUrl(googleUrl, outputPath);
+  if (success) {
+    try {
+      const stats = fs.statSync(outputPath);
+      if (stats.size > 1000) {
+        stopSpinner(true, 'Favicon downloaded successfully!');
+        return true; 
+      }
+      fs.unlinkSync(outputPath);
+    } catch (e) {}
+  }
+
+  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) {}
+
+  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) {}
+
+  stopSpinner(false, 'Could not download favicon. Fallback to default Electron icon.');
+  return false;
+}
+
+module.exports = {
+  parseUrlDetails,
+  downloadFaviconFlow
+};