deskify-cli 1.0.3 → 1.0.5

package/deskify.js

@@ -12,6 +12,7 @@ const { colors, log } = require('./src/utils/colors');
 const { selectOption, waitForKey } = require('./src/utils/prompts');
 const { startSpinner, stopSpinner } = require('./src/utils/spinner');
 const { createFlow } = require('./src/flows/create');
+const { manageFlow } = require('./src/flows/manage');
 const { uninstallFlow } = require('./src/flows/uninstall');
 
 function printHeader() {
@@ -67,6 +68,7 @@ async function main() {
 
     const options = [
       'Create a new Desktop App',
+      'List & Manage existing Apps',
       'Uninstall an existing App',
       'Exit'
     ];
@@ -89,6 +91,14 @@ async function main() {
         await waitForKey();
       }
     } else if (selectedIdx === 1) {
+      try {
+        await manageFlow(hasDesktopUtils);
+      } catch (e) {
+        log.error('An error occurred during application management:');
+        console.error(e);
+        await waitForKey();
+      }
+    } else if (selectedIdx === 2) {
       try {
         const result = await uninstallFlow(hasDesktopUtils);
         if (result && result.success) {
@@ -103,7 +113,7 @@ async function main() {
         console.error(e);
         await waitForKey();
       }
-    } else if (selectedIdx === 2) {
+    } else if (selectedIdx === 3) {
       log.info('Thank you for using Deskify! Goodbye! 👋');
       process.exit(0);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "deskify-cli",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "description": "An interactive, zero-dependency CLI tool to turn web pages into Linux desktop applications using Nativefier.",
   "main": "deskify.js",
   "bin": {

package/src/flows/create.js

@@ -24,12 +24,25 @@ function printHeader() {
   console.log(`${colors.dim}--------------------------------------------------${colors.reset}\n`);
 }
 
-async function createFlow(hasDesktopUtils) {
+async function createFlow(hasDesktopUtils, existingConfig = null) {
   console.clear();
   printHeader();
-  log.bold('--- Create a New Desktop Application ---');
+  if (existingConfig) {
+    log.bold(`--- Edit/Update Desktop Application: ${existingConfig.appName} ---`);
+  } else {
+    log.bold('--- Create a New Desktop Application ---');
+  }
   console.log('');
 
+  let defaultTargetUrl = existingConfig ? existingConfig.url : '';
+  let defaultAppName = existingConfig ? existingConfig.appName : '';
+  let defaultPersist = existingConfig ? existingConfig.persist : true;
+  let defaultInternalUrls = existingConfig ? existingConfig.internalUrls : '';
+  let defaultWidth = existingConfig ? existingConfig.width : '1200';
+  let defaultHeight = existingConfig ? existingConfig.height : '800';
+  let defaultInstallPath = existingConfig ? path.dirname(existingConfig.appFolder) : '~/Apps';
+  let defaultNoSandbox = existingConfig ? existingConfig.noSandbox : false;
+
   let targetUrl = '';
   let appName = '';
   let iconPath = '';
@@ -38,11 +51,12 @@ async function createFlow(hasDesktopUtils) {
   let width = '1200';
   let height = '800';
   let installPath = '';
+  let noSandbox = false;
 
   try {
     let targetUrlInput = '';
     while (!targetUrlInput) {
-      targetUrlInput = await ask('Enter Website URL (e.g., https://nextcloud.com)');
+      targetUrlInput = await ask('Enter Website URL (e.g., https://nextcloud.com)', defaultTargetUrl);
       if (!targetUrlInput) {
         log.error('URL cannot be empty. Please try again.');
       }
@@ -53,7 +67,7 @@ async function createFlow(hasDesktopUtils) {
     
     log.info(`Parsed Target URL: ${colors.bright}${targetUrl}${colors.reset}`);
 
-    appName = await ask('Enter Application Name', urlDetails.nameDefault);
+    appName = await ask('Enter Application Name', defaultAppName || urlDetails.nameDefault);
 
     const useFavicon = await askYesNo('Download and use website favicon as app icon?', true);
     
@@ -81,12 +95,13 @@ async function createFlow(hasDesktopUtils) {
       }
     }
 
-    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');
+    persistSession = await askYesNo('Persist session cookies, local storage, and cache?', defaultPersist);
+    internalUrlsRegex = await ask('Internal URL pattern regex', defaultInternalUrls || urlDetails.regexDefault);
+    width = await ask('Window width (pixels)', defaultWidth);
+    height = await ask('Window height (pixels)', defaultHeight);
+    noSandbox = await askYesNo('Disable Chromium sandbox (avoids requiring sudo)?', defaultNoSandbox);
 
-    const installPathInput = await ask('Installation directory', '~/Apps');
+    const installPathInput = await ask('Installation directory', defaultInstallPath);
     installPath = expandHome(installPathInput);
 
     console.log(`\n${colors.bright}--- Build Configuration Summary ---${colors.reset}`);
@@ -95,6 +110,7 @@ async function createFlow(hasDesktopUtils) {
     console.log(`Persist:       ${persistSession ? 'Yes' : 'No'}`);
     console.log(`Internal URLs: ${internalUrlsRegex}`);
     console.log(`Dimensions:    ${width}x${height}`);
+    console.log(`Disable Sandbox: ${noSandbox ? 'Yes (Sudo-free)' : 'No (Requires Sudo)'}`);
     console.log(`Install Dir:   ${installPath}`);
     if (iconPath) {
       console.log(`Icon Path:     ${iconPath}`);
@@ -114,6 +130,16 @@ async function createFlow(hasDesktopUtils) {
     throw e;
   }
 
+  // Deleting the existing application folder before rebuild to avoid folder name collisions
+  if (existingConfig && existingConfig.appFolder && fs.existsSync(existingConfig.appFolder)) {
+    log.info(`Deleting existing application folder for update: ${existingConfig.appFolder}`);
+    try {
+      fs.rmSync(existingConfig.appFolder, { recursive: true, force: true });
+    } catch (e) {
+      log.warn(`Could not delete existing folder: ${e.message}`);
+    }
+  }
+
   if (!fs.existsSync(installPath)) {
     log.info(`Creating installation directory: ${installPath}`);
     fs.mkdirSync(installPath, { recursive: true });
@@ -210,20 +236,24 @@ async function createFlow(hasDesktopUtils) {
     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}"`);
-    }
+  if (noSandbox) {
+    log.info('\n[4/4] Skipping chrome-sandbox permissions adjustment (sandbox disabled)...');
   } else {
-    log.warn('chrome-sandbox file not found in build directory. Skipping permission adjustment.');
+    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...');
@@ -232,6 +262,16 @@ async function createFlow(hasDesktopUtils) {
     fs.mkdirSync(desktopEntriesDir, { recursive: true });
   }
 
+  // Delete the old desktop shortcut if updating to avoid leftovers (e.g. if the name changed)
+  if (existingConfig && existingConfig.filePath && fs.existsSync(existingConfig.filePath)) {
+    try {
+      fs.unlinkSync(existingConfig.filePath);
+      log.info(`Cleaned up old desktop shortcut: ${existingConfig.filePath}`);
+    } catch (e) {
+      log.warn(`Could not delete old desktop shortcut: ${e.message}`);
+    }
+  }
+
   const desktopFilePath = path.join(desktopEntriesDir, `${appName.replace(/\s+/g, '')}.desktop`);
   const execPath = path.join(appFolder, appName);
   const finalIconPath = fs.existsSync(destIconPath) ? destIconPath : (iconPath || 'electron');
@@ -239,13 +279,19 @@ async function createFlow(hasDesktopUtils) {
   const desktopContent = `[Desktop Entry]
 Name=${appName}
 Comment=${appName} Web Desktop App
-Exec=${execPath}
+Exec=${execPath}${noSandbox ? ' --no-sandbox' : ''}
 Icon=${finalIconPath}
 Terminal=false
 Type=Application
 Categories=Network;WebBrowser;Application;
 StartupWMClass=${startupWMClass}
 X-Generated-By=deskify
+X-Deskify-URL=${targetUrl}
+X-Deskify-Width=${width}
+X-Deskify-Height=${height}
+X-Deskify-Persist=${persistSession}
+X-Deskify-NoSandbox=${noSandbox}
+X-Deskify-InternalUrls=${internalUrlsRegex}
 `;
 
   try {

package/src/flows/manage.js

@@ -0,0 +1,240 @@
+/**
+ * manage.js
+ * Application list and management flow for the deskify CLI.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { execSync, spawn } = require('child_process');
+const { colors, log } = require('../utils/colors');
+const { expandHome, selectOption, askYesNo, waitForKey } = require('../utils/prompts');
+const { createFlow } = require('./create');
+
+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 getDeskifyApps() {
+  const desktopEntriesDir = expandHome('~/.local/share/applications');
+  if (!fs.existsSync(desktopEntriesDir)) {
+    return [];
+  }
+
+  const files = fs.readdirSync(desktopEntriesDir);
+  const apps = [];
+
+  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 iconMatch = content.match(/^Icon=(.+)$/m);
+          
+          const urlMatch = content.match(/^X-Deskify-URL=(.+)$/m);
+          const widthMatch = content.match(/^X-Deskify-Width=(.+)$/m);
+          const heightMatch = content.match(/^X-Deskify-Height=(.+)$/m);
+          const persistMatch = content.match(/^X-Deskify-Persist=(.+)$/m);
+          const noSandboxMatch = content.match(/^X-Deskify-NoSandbox=(.+)$/m);
+          const internalUrlsMatch = content.match(/^X-Deskify-InternalUrls=(.+)$/m);
+
+          const appName = nameMatch ? nameMatch[1].trim() : file.replace('.desktop', '');
+          let execRaw = execMatch ? execMatch[1].trim() : '';
+          
+          if (execRaw.startsWith('"') && execRaw.endsWith('"')) {
+            execRaw = execRaw.slice(1, -1);
+          }
+
+          let execPath = execRaw;
+          let hasNoSandboxFlag = execRaw.includes('--no-sandbox');
+          if (hasNoSandboxFlag) {
+            execPath = execRaw.replace('--no-sandbox', '').trim();
+          }
+
+          let appFolder = execPath ? path.dirname(execPath) : '';
+
+          apps.push({
+            file,
+            filePath,
+            appName,
+            execPath,
+            appFolder,
+            icon: iconMatch ? iconMatch[1].trim() : '',
+            url: urlMatch ? urlMatch[1].trim() : '',
+            width: widthMatch ? widthMatch[1].trim() : '1200',
+            height: heightMatch ? heightMatch[1].trim() : '800',
+            persist: persistMatch ? persistMatch[1].trim() === 'true' : true,
+            noSandbox: noSandboxMatch ? noSandboxMatch[1].trim() === 'true' : hasNoSandboxFlag,
+            internalUrls: internalUrlsMatch ? internalUrlsMatch[1].trim() : ''
+          });
+        }
+      } catch (e) {}
+    }
+  }
+  return apps;
+}
+
+async function uninstallSingleApp(hasDesktopUtils, app) {
+  log.warn(`\nAre you sure you want to permanently delete ${colors.red}${app.appName}${colors.reset}?`);
+  log.warn('This will delete:');
+  log.warn(`  - Shortcut:  ${app.filePath}`);
+  if (app.appFolder && fs.existsSync(app.appFolder)) {
+    log.warn(`  - App Folder: ${app.appFolder}`);
+  }
+  console.log('');
+
+  try {
+    const confirm = await askYesNo('Confirm uninstallation?', false);
+    if (!confirm) {
+      log.info('Uninstallation cancelled.');
+      return false;
+    }
+  } catch (e) {
+    if (e.message === 'ESC') {
+      log.warn('\nUninstallation cancelled by user (ESC pressed).');
+      return false;
+    }
+    throw e;
+  }
+
+  try {
+    if (fs.existsSync(app.filePath)) {
+      fs.unlinkSync(app.filePath);
+      log.success(`Deleted shortcut file: ${app.file}`);
+    }
+  } catch (e) {
+    log.error(`Failed to delete shortcut file: ${e.message}`);
+  }
+
+  if (app.appFolder && fs.existsSync(app.appFolder)) {
+    log.info(`Deleting application files at: ${app.appFolder}...`);
+    try {
+      fs.rmSync(app.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 "${app.appFolder}"`);
+    }
+  }
+
+  if (hasDesktopUtils) {
+    log.info('Updating desktop shortcuts registry database...');
+    try {
+      const desktopEntriesDir = expandHome('~/.local/share/applications');
+      execSync(`update-desktop-database "${desktopEntriesDir}"`, { stdio: 'ignore' });
+      log.success('Desktop shortcuts database updated!');
+    } catch (e) {}
+  }
+
+  log.success(`\n🎉 ${app.appName} has been uninstalled successfully! 🗑️\n`);
+  return true;
+}
+
+async function manageSingleApp(hasDesktopUtils, app) {
+  while (true) {
+    console.clear();
+    printHeader();
+    log.bold(`--- Application: ${app.appName} ---`);
+    console.log('');
+    console.log(`Name:        ${colors.bright}${app.appName}${colors.reset}`);
+    console.log(`URL:         ${colors.cyan}${app.url || 'N/A'}${colors.reset}`);
+    console.log(`Sandbox:     ${app.noSandbox ? colors.green + 'Disabled (Sudo-free)' : colors.yellow + 'Enabled (Requires Sudo setup)'}${colors.reset}`);
+    console.log(`Persist:     ${app.persist ? 'Yes' : 'No'}`);
+    console.log(`Window Size: ${app.width}x${app.height}`);
+    console.log(`Folder:      ${app.appFolder}`);
+    console.log(`Shortcut:    ${app.filePath}`);
+    console.log('');
+
+    const options = [
+      'Launch Application',
+      'Edit / Update Configuration',
+      'Uninstall Application',
+      'Back to List'
+    ];
+
+    const selectedIdx = await selectOption('Choose action', options, 0);
+
+    if (selectedIdx === 0) {
+      log.info(`Launching ${app.appName} in background...`);
+      try {
+        const runExec = app.noSandbox ? `"${app.execPath}" --no-sandbox` : `"${app.execPath}"`;
+        const child = spawn(runExec, [], {
+          shell: true,
+          detached: true,
+          stdio: 'ignore'
+        });
+        child.unref();
+        log.success('Launched successfully!');
+        await new Promise(r => setTimeout(r, 1500));
+      } catch (e) {
+        log.error(`Failed to launch application: ${e.message}`);
+        await waitForKey();
+      }
+    } else if (selectedIdx === 1) {
+      const result = await createFlow(hasDesktopUtils, app);
+      if (result && result.success) {
+        const refreshedApps = await getDeskifyApps();
+        const updated = refreshedApps.find(a => a.filePath === app.filePath || a.appName === app.appName);
+        if (updated) {
+          app = updated;
+        } else {
+          return; 
+        }
+        await waitForKey();
+      }
+    } else if (selectedIdx === 2) {
+      const success = await uninstallSingleApp(hasDesktopUtils, app);
+      if (success) {
+        await waitForKey();
+        return; 
+      }
+    } else if (selectedIdx === 3) {
+      return; 
+    }
+  }
+}
+
+async function manageFlow(hasDesktopUtils) {
+  while (true) {
+    console.clear();
+    printHeader();
+    log.bold('--- List & Manage Existing Applications ---');
+    console.log('');
+
+    const apps = await getDeskifyApps();
+
+    if (apps.length === 0) {
+      log.info('No applications generated by deskify were found.');
+      await waitForKey();
+      return;
+    }
+
+    const options = apps.map(app => `${app.appName} ${colors.dim}(${app.url || 'No URL stored'})${colors.reset}`);
+    options.push('Back to Main Menu');
+
+    const selectedIdx = await selectOption('Select an application to manage', options, 0);
+
+    if (selectedIdx === options.length - 1) {
+      return;
+    }
+
+    const targetApp = apps[selectedIdx];
+    await manageSingleApp(hasDesktopUtils, targetApp);
+  }
+}
+
+module.exports = {
+  manageFlow
+};

package/src/utils/prompts.js

@@ -25,8 +25,7 @@ function ask(questionText, defaultValue = '') {
     
     let buffer = '';
     const rl = readline.createInterface({
-      input: process.stdin,
-      output: process.stdout
+      input: process.stdin
     });
     
     readline.emitKeypressEvents(process.stdin, rl);
@@ -91,8 +90,7 @@ function selectOption(questionText, options, defaultIndex = 0) {
   return new Promise((resolve) => {
     let selectedIndex = defaultIndex;
     const rl = readline.createInterface({
-      input: process.stdin,
-      output: process.stdout
+      input: process.stdin
     });
     
     readline.emitKeypressEvents(process.stdin, rl);