@glassnote/client 2.4.0

package/autoStart.js

@@ -0,0 +1,608 @@
+// electron se carga de forma perezosa: este módulo también lo usa el CLI (node puro),
+// que necesita `removeAutoStart()` para `glassnote uninstall`.
+let app = null;
+try {
+  ({ app } = require('electron'));
+} catch (error) {
+  app = null;
+}
+const npmMode = require('./npmMode');
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+const { execSync, spawn } = require('child_process');
+
+class AutoStart {
+  constructor() {
+    this.platform = process.platform;
+  }
+
+  // Comando con el que se vuelve a arrancar el cliente.
+  //
+  // Instalado por npm/npx no hay ningún `glassnote.exe`: el ejecutable ES el binario de
+  // electron que bajó npm, y la app va como argumento. Sin esto los tres autoarranques
+  // de abajo se salían sin hacer nada (comprueban que el binario se llame glassnote) y
+  // el cliente no volvía a abrirse nunca solo.
+  getLaunchCommand() {
+    if (npmMode.isNpmMode()) {
+      // Las banderas del sandbox van también aquí: sin ellas el arranque automático
+      // fallaría en las máquinas donde Chromium aborta, y el fallo no lo vería nadie
+      // porque nadie mira la salida de una entrada de autoarranque.
+      return {
+        exec: process.execPath,
+        args: [npmMode.PACKAGE_ROOT].concat(npmMode.sandboxFlags(process.execPath)),
+      };
+    }
+    return { exec: this.getExecutablePath(), args: [] };
+  }
+
+  // Get the path to the executable (app when packaged, or electron during development)
+  getExecutablePath() {
+    
+    if (app && app.isPackaged) {
+      const appPath = process.execPath;
+      const executableName = path.basename(appPath).toLowerCase();
+      
+      // Platform-specific expected names
+      let expectedName = '';
+      if (this.platform === 'win32') {
+        expectedName = 'glassnote.exe';
+      } else if (this.platform === 'darwin') {
+        expectedName = 'glassnote'; // macOS - sin extensión
+      } else if (this.platform === 'linux') {
+        expectedName = 'glassnote'; // Linux - sin extensión
+      }
+      
+      // Check if the executable has the expected name for the platform
+      if (executableName !== expectedName) {
+        return appPath;
+      }
+      
+      return appPath;
+    } else {
+      // In development, we need to start the app with electron
+      return process.execPath;
+    }
+  }
+
+  // Windows auto-start implementation
+  setupWindowsAutoStart() {
+    try {
+      
+      // Create shortcuts in both locations
+      const startupPaths = [
+        path.join(
+          process.env.APPDATA,
+          'Microsoft',
+          'Windows',
+          'Start Menu',
+          'Programs',
+          'Startup',
+          'glassnote.lnk'
+        ),
+        path.join(
+          process.env.APPDATA,
+          'Microsoft',
+          'Windows',
+          'Start Menu',
+          'Programs',
+          'glassnote.lnk'
+        )
+      ];
+
+      const { exec: executablePath, args: launchArgs } = this.getLaunchCommand();
+      
+      // Verify the executable exists and is named glassnote.exe
+      if (!fs.existsSync(executablePath)) {
+        console.error('Executable not found:', executablePath);
+        console.error('Directory contents:', fs.readdirSync(path.dirname(executablePath) || '.'));
+        return false;
+      }
+      
+      const executableName = path.basename(executablePath).toLowerCase();
+      
+      // Only create shortcuts if the executable is named glassnote.exe
+      // Don't delete existing shortcuts if the name doesn't match
+      // (en modo npm el binario es electron.exe y el nombre no aplica)
+      if (!npmMode.isNpmMode() && executableName !== 'glassnote.exe') {
+        return true; // Return true to indicate "success" without modifying shortcuts
+      }
+
+      // La carpeta de trabajo: la del paquete en modo npm, la del ejecutable en nativo.
+      const workingDir = launchArgs.length ? launchArgs[0] : path.dirname(executablePath);
+
+      let allSuccess = true;
+
+      for (const startupPath of startupPaths) {
+
+        try {
+          // Remove existing shortcut if it exists
+          if (fs.existsSync(startupPath)) {
+            fs.unlinkSync(startupPath);
+          } else {
+          }
+        } catch (error) {
+          console.error('Could not remove existing shortcut (access may be restricted):', error.message);
+          // Continue with creation attempt even if removal failed
+        }
+
+        try {
+          // Create shortcut using Windows Script Host
+          const script = `
+            Set oWS = WScript.CreateObject("WScript.Shell")
+            Set oLink = oWS.CreateShortcut("${startupPath.replace(/\\/g, '\\\\')}")
+            oLink.TargetPath = "${executablePath.replace(/\\/g, '\\\\')}"
+            oLink.Arguments = "${launchArgs.map((a) => `""${a.replace(/\\/g, '\\\\')}""`).join(' ')}"
+            oLink.WorkingDirectory = "${workingDir.replace(/\\/g, '\\\\')}"
+            oLink.WindowStyle = 7
+            oLink.Save
+          `;
+
+          // Use temp directory instead of app directory (app.asar is read-only)
+          const tempDir = os.tmpdir();
+          const tempScriptPath = path.join(tempDir, 'glassnote_create_shortcut.vbs');
+          
+          fs.writeFileSync(tempScriptPath, script);
+
+          execSync(`cscript //nologo "${tempScriptPath}"`);
+
+          fs.unlinkSync(tempScriptPath);
+
+          // Verify the shortcut was created
+          if (fs.existsSync(startupPath)) {
+          } else {
+            // Don't mark as failure if access is restricted
+            try {
+              if (fs.existsSync(path.dirname(startupPath))) {
+              }
+            } catch (dirError) {
+              console.error('Cannot access directory (access restricted):', dirError.message);
+            }
+            // Continue without marking as failure
+          }
+        } catch (error) {
+          console.error('Could not create shortcut (access may be restricted):', error.message);
+          // Don't mark as failure if access is restricted
+        }
+      }
+
+      if (allSuccess) {
+        return true;
+      } else {
+        console.error('Windows auto-start configuration partially failed');
+        return false;
+      }
+    } catch (error) {
+      console.error('Error configuring Windows auto-start:', error);
+      console.error('Error message:', error.message);
+      if (error.stdout) console.error('stdout:', error.stdout.toString());
+      if (error.stderr) console.error('stderr:', error.stderr.toString());
+      return false;
+    }
+  }
+
+  // macOS auto-start implementation
+  setupMacAutoStart() {
+    try {
+      
+      const plistPath = path.join(
+        process.env.HOME,
+        'Library',
+        'LaunchAgents',
+        'com.glassnote.app.plist'
+      );
+
+
+      const { exec: executablePath, args: launchArgs } = this.getLaunchCommand();
+      
+      // Verify the executable exists
+      if (!fs.existsSync(executablePath)) {
+        console.error('Executable not found:', executablePath);
+        return false;
+      }
+
+      // Check if the executable is named glassnote (macOS binary name)
+      const executableName = path.basename(executablePath).toLowerCase();
+      
+      // Instalado por npm el binario es el Electron de node_modules y no está en
+      // /Applications: las dos comprobaciones de abajo solo valen para el .app nativo.
+      if (!npmMode.isNpmMode()) {
+        // Only create plist if the executable is named glassnote
+        // Don't remove existing plist if the name doesn't match
+        if (executableName !== 'glassnote') {
+          return true; // Return true to indicate "success" without modifying plist
+        }
+
+        // Only create auto-start if the application is installed in the Applications folder
+        const applicationsPath = '/Applications/';
+        if (!executablePath.startsWith(applicationsPath)) {
+          return true; // Return true to indicate "success" without modifying plist
+        }
+      }
+
+      // Remove existing plist if it exists
+      if (fs.existsSync(plistPath)) {
+        try {
+          // Use spawn instead of execSync to avoid blocking
+          const unloadProcess = spawn('launchctl', ['unload', plistPath], {
+            stdio: 'ignore',
+            timeout: 5000 // 5 second timeout
+          });
+          
+          unloadProcess.on('error', (error) => {
+          });
+          
+          unloadProcess.on('exit', (code) => {
+            if (code !== 0) {
+              console.warn('launchctl unload exited with code:', code, '(may not be loaded)');
+            }
+          });
+        } catch (error) {
+          console.error('Could not unload existing plist:', error.message);
+        }
+        
+        // Remove the plist file regardless of launchctl status
+        try {
+          fs.unlinkSync(plistPath);
+        } catch (error) {
+          console.error('Could not remove plist file:', error.message);
+        }
+      }
+
+      const plistContent = `<?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>Label</key>
+  <string>com.glassnote.app</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${executablePath}</string>
+${launchArgs.map((a) => `    <string>${a}</string>`).join('\n')}
+  </array>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <false/>
+</dict>
+</plist>`;
+
+      // Create directory if it doesn't exist
+      const plistDir = path.dirname(plistPath);
+      if (!fs.existsSync(plistDir)) {
+        fs.mkdirSync(plistDir, { recursive: true });
+      }
+
+      fs.writeFileSync(plistPath, plistContent);
+
+      // Load the launch agent asynchronously
+      try {
+        const loadProcess = spawn('launchctl', ['load', plistPath], {
+          stdio: 'ignore',
+          timeout: 5000 // 5 second timeout
+        });
+        
+        loadProcess.on('error', (error) => {
+          console.error('Error spawning launchctl load:', error.message);
+        });
+        
+        loadProcess.on('exit', (code) => {
+          if (code !== 0) {
+            console.warn('launchctl load exited with code:', code);
+          } else {
+            console.warn('macOS auto-start configured:', plistPath);
+          }
+        });
+      } catch (error) {
+        console.error('Error loading launch agent:', error.message);
+      }
+
+      return true;
+    } catch (error) {
+      console.error('Error configuring macOS auto-start:', error);
+      console.error('Error message:', error.message);
+      return false;
+    }
+  }
+
+  // Linux auto-start implementation
+  setupLinuxAutoStart() {
+    try {
+      
+      const desktopFilePaths = [
+        path.join(process.env.HOME, '.local', 'share', 'applications', 'glassnote.desktop'),
+        path.join(process.env.HOME, '.config', 'autostart', 'glassnote.desktop')
+      ];
+
+      const { exec: executablePath, args: launchArgs } = this.getLaunchCommand();
+      
+      // Verify the executable exists
+      if (!fs.existsSync(executablePath)) {
+        console.error('Executable not found:', executablePath);
+        return false;
+      }
+
+      // Check if the executable is named glassnote (Linux typically uses the binary name)
+      const executableName = path.basename(executablePath).toLowerCase();
+      
+      // En modo npm el binario se llama `electron`: la comprobación de nombre solo vale
+      // para el empaquetado nativo.
+      if (!npmMode.isNpmMode() && executableName !== 'glassnote') {
+        return true; // Return true to indicate "success" without modifying desktop files
+      }
+
+      // Comillas en Exec: la ruta del paquete npm puede tener espacios.
+      const execLine = [executablePath].concat(launchArgs).map((a) => `"${a}"`).join(' ');
+      const desktopContent = `[Desktop Entry]
+Type=Application
+Name=Glassnote
+Exec=${execLine}
+Icon=${npmMode.isNpmMode() ? path.join(npmMode.PACKAGE_ROOT, 'images', 'icon.png') : 'glassnote'}
+Categories=Utility;
+Terminal=false
+StartupWMClass=glassnote`;
+
+      for (const desktopFilePath of desktopFilePaths) {
+        
+        // Remove existing desktop file if it exists
+        if (fs.existsSync(desktopFilePath)) {
+          fs.unlinkSync(desktopFilePath);
+        }
+
+        const desktopDir = path.dirname(desktopFilePath);
+        if (!fs.existsSync(desktopDir)) {
+          fs.mkdirSync(desktopDir, { recursive: true });
+        }
+
+        fs.writeFileSync(desktopFilePath, desktopContent);
+
+        // Set executable permissions
+        try {
+          execSync(`chmod +x "${desktopFilePath}"`);
+        } catch (error) {
+          console.error('Could not set executable permissions (may be ignored):', error.message);
+        }
+      }
+
+      // Update desktop database
+      try {
+        execSync('update-desktop-database ~/.local/share/applications');
+      } catch (error) {
+        console.error('Could not update desktop database (may be ignored):', error.message);
+      }
+
+      return true;
+    } catch (error) {
+      console.error('Error configuring Linux auto-start:', error);
+      console.error('Error message:', error.message);
+      return false;
+    }
+  }
+
+  // Check if auto-start is already configured
+  isAutoStartConfigured() {
+    try {
+      
+      switch (this.platform) {
+        case 'win32':
+          try {
+            // Check both startup and programs menu shortcuts
+            const winPaths = [
+              path.join(
+                process.env.APPDATA,
+                'Microsoft',
+                'Windows',
+                'Start Menu',
+                'Programs',
+                'Startup',
+                'glassnote.lnk'
+              ),
+              path.join(
+                process.env.APPDATA,
+                'Microsoft',
+                'Windows',
+                'Start Menu',
+                'Programs',
+                'glassnote.lnk'
+              )
+            ];
+            
+            for (const winPath of winPaths) {
+              try {
+                if (fs.existsSync(winPath)) {
+                  return true; // Return true if any shortcut exists
+                }
+              } catch (error) {
+                console.error('Cannot check Windows shortcut (access may be restricted):', winPath, error.message);
+                // Continue checking other paths
+              }
+            }
+            return false;
+          } catch (error) {
+            console.error('Cannot check Windows auto-start configuration (access may be restricted):', error.message);
+            return false; // Assume not configured if access is restricted
+          }
+
+        case 'darwin':
+          try {
+            const macPath = path.join(
+              process.env.HOME,
+              'Library',
+              'LaunchAgents',
+              'com.glassnote.app.plist'
+            );
+            const macExists = fs.existsSync(macPath);
+            return macExists;
+          } catch (error) {
+            console.error('Cannot check macOS auto-start configuration (access may be restricted):', error.message);
+            return false; // Assume not configured if access is restricted
+          }
+
+        case 'linux':
+          try {
+            const linuxPath = path.join(
+              process.env.HOME,
+              '.config',
+              'autostart',
+              'glassnote.desktop'
+            );
+            const linuxExists = fs.existsSync(linuxPath);
+            return linuxExists;
+          } catch (error) {
+            console.error('Cannot check Linux auto-start configuration (access may be restricted):', error.message);
+            return false; // Assume not configured if access is restricted
+          }
+
+        default:
+          return false;
+      }
+    } catch (error) {
+      console.error('Error checking auto-start configuration:', error.message);
+      return false;
+    }
+  }
+
+  // Main method to configure auto-start
+  configureAutoStart() {
+    try {
+      let result = false;
+      switch (this.platform) {
+        case 'win32':
+          result = this.setupWindowsAutoStart();
+          break;
+
+        case 'darwin':
+          result = this.setupMacAutoStart();
+          break;
+
+        case 'linux':
+          result = this.setupLinuxAutoStart();
+          break;
+
+        default:
+          result = false;
+      }
+      
+      if (!result) {
+        console.warn('Auto-start configuration may have failed due to access restrictions, but application will continue running normally');
+      }
+      
+      return result;
+    } catch (error) {
+      console.error('Auto-start configuration failed due to error, but application will continue running normally:', error.message);
+      return false; // Return false but don't throw error
+    }
+  }
+
+  // Remove auto-start configuration
+  removeAutoStart() {
+    try {
+      switch (this.platform) {
+        case 'win32':
+          // Remove both startup and programs menu shortcuts
+          const winPaths = [
+            path.join(
+              process.env.APPDATA,
+              'Microsoft',
+              'Windows',
+              'Start Menu',
+              'Programs',
+              'Startup',
+              'glassnote.lnk'
+            ),
+            path.join(
+              process.env.APPDATA,
+              'Microsoft',
+              'Windows',
+              'Start Menu',
+              'Programs',
+              'glassnote.lnk'
+            )
+          ];
+          
+          for (const winPath of winPaths) {
+            try {
+              if (fs.existsSync(winPath)) {
+                fs.unlinkSync(winPath);
+              } else {
+              }
+            } catch (error) {
+              console.error('Could not remove Windows shortcut (access may be restricted):', winPath, error.message);
+              // Continue without error - removal is optional
+            }
+          }
+          break;
+
+        case 'darwin':
+          try {
+            const macPath = path.join(
+              process.env.HOME,
+              'Library',
+              'LaunchAgents',
+              'com.glassnote.app.plist'
+            );
+            if (fs.existsSync(macPath)) {
+              try {
+                // Use spawn instead of execSync to avoid blocking
+                const unloadProcess = spawn('launchctl', ['unload', macPath], {
+                  stdio: 'ignore',
+                  timeout: 5000 // 5 second timeout
+                });
+                
+                unloadProcess.on('error', (error) => {
+                  console.error('Error spawning launchctl unload:', error.message);
+                });
+                
+                unloadProcess.on('exit', (code) => {
+                  if (code !== 0) {
+                    console.warn('launchctl unload exited with code:', code, '(may not be loaded)');
+                  }
+                });
+              } catch (error) {
+                console.error('Could not unload plist:', error.message);
+              }
+              
+              // Remove the plist file regardless of launchctl status
+              try {
+                fs.unlinkSync(macPath);
+              } catch (error) {
+                console.error('Could not remove plist file:', error.message);
+              }
+            } else {
+              console.warn('macOS auto-start plist not found');
+            }
+          } catch (error) {
+            console.error('Could not remove macOS auto-start configuration (access may be restricted):', error.message);
+            // Continue without error - removal is optional
+          }
+          break;
+
+        case 'linux':
+          try {
+            const linuxPaths = [
+              path.join(process.env.HOME, '.local', 'share', 'applications', 'glassnote.desktop'),
+              path.join(process.env.HOME, '.config', 'autostart', 'glassnote.desktop')
+            ];
+            for (const linuxPath of linuxPaths) {
+              if (fs.existsSync(linuxPath)) {
+                fs.unlinkSync(linuxPath);
+              } else {
+                console.warn('Linux desktop file not found:', linuxPath);
+              }
+            }
+          } catch (error) {
+            console.error('Could not remove Linux auto-start configuration (access may be restricted):', error.message);
+            // Continue without error - removal is optional
+          }
+          break;
+      }
+
+      return true; // Always return true since removal is optional
+    } catch (error) {
+      console.error('Error removing auto-start configuration:', error.message);
+      return true; // Return true even if there's an error - removal is optional
+    }
+  }
+}
+
+module.exports = AutoStart;