Function: Implement auto startup

Author: ShenKSPZ

app/main.ts

@@ -1,5 +1,5 @@
 /* eslint-disable @typescript-eslint/no-unused-vars */
-import {app, BrowserWindow, ipcMain, shell, dialog} from 'electron';
+import {app, BrowserWindow, ipcMain, shell, dialog, Tray, Menu, nativeImage} from 'electron';
 import * as path from 'path';
 import * as fs from 'fs';
 import * as os from 'os';
@@ -8,11 +8,147 @@ import { execSync } from 'child_process';
 
 // Main window reference
 let win: BrowserWindow | null = null;
+// Tray reference
+let tray: Tray | null = null;
+
+// Settings
+let closeToTray = true;
 
 // Check if app is running in development mode
 const args = process.argv.slice(1);
 const serve = args.some(val => val === '--serve');
 
+/**
+ * Create the system tray
+ */
+function createTray() {
+  if (tray) {
+    return;
+  }
+
+  // Get appropriate icon based on platform
+  const iconPath = path.join(__dirname, '..', 'dist', 'logos', 'favicon.256x256.png');
+  const icon = nativeImage.createFromPath(iconPath);
+  
+  tray = new Tray(icon);
+  tray.setToolTip('TensorBlock Desktop');
+  
+  const contextMenu = Menu.buildFromTemplate([
+    { label: 'Open TensorBlock', click: () => { 
+      win?.show(); 
+      win?.setSkipTaskbar(false); // Show in taskbar
+    }},
+    { type: 'separator' },
+    { label: 'Quit', click: () => { app.quit(); } }
+  ]);
+  
+  tray.setContextMenu(contextMenu);
+  
+  tray.on('click', () => {
+    if (win) {
+      if (win.isVisible()) {
+        win.hide();
+        win.setSkipTaskbar(true); // Hide from taskbar
+      } else {
+        win.show();
+        win.setSkipTaskbar(false); // Show in taskbar
+      }
+    }
+  });
+}
+
+/**
+ * Set or remove auto launch on system startup
+ */
+function setAutoLaunch(enable: boolean): boolean {
+  try {
+    if (process.platform === 'win32') {
+      const appPath = app.getPath('exe');
+      const regKey = 'HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Run';
+      const appName = app.getName();
+      
+      if (enable) {
+        // Add to registry to enable auto launch
+        execSync(`reg add ${regKey} /v ${appName} /t REG_SZ /d "${appPath}" /f`);
+      } else {
+        // Remove from registry to disable auto launch
+        execSync(`reg delete ${regKey} /v ${appName} /f`);
+      }
+      return true;
+    } else if (process.platform === 'darwin') {
+      const appPath = app.getPath('exe');
+      const loginItemSettings = app.getLoginItemSettings();
+      
+      // Set login item settings for macOS
+      app.setLoginItemSettings({
+        openAtLogin: enable,
+        path: appPath
+      });
+      
+      return app.getLoginItemSettings().openAtLogin === enable;
+    } else if (process.platform === 'linux') {
+      // For Linux, create or remove a .desktop file in autostart directory
+      const desktopFilePath = path.join(os.homedir(), '.config', 'autostart', `${app.getName()}.desktop`);
+      
+      if (enable) {
+        // Create directory if it doesn't exist
+        const autoStartDir = path.dirname(desktopFilePath);
+        if (!fs.existsSync(autoStartDir)) {
+          fs.mkdirSync(autoStartDir, { recursive: true });
+        }
+        
+        // Create .desktop file
+        const desktopFileContent = `
+          [Desktop Entry]
+          Type=Application
+          Exec=${app.getPath('exe')}
+          Hidden=false
+          NoDisplay=false
+          X-GNOME-Autostart-enabled=true
+          Name=${app.getName()}
+          Comment=${app.getName()} startup script
+          `;
+        fs.writeFileSync(desktopFilePath, desktopFileContent);
+      } else if (fs.existsSync(desktopFilePath)) {
+        // Remove .desktop file
+        fs.unlinkSync(desktopFilePath);
+      }
+      
+      return true;
+    }
+    
+    return false;
+  } catch (error) {
+    console.error('Error setting auto launch:', error);
+    return false;
+  }
+}
+
+/**
+ * Check if app is set to auto launch on system startup
+ */
+function getAutoLaunchEnabled(): boolean {
+  try {
+    if (process.platform === 'win32') {
+      const regKey = 'HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Run';
+      const appName = app.getName();
+      
+      const output = execSync(`reg query ${regKey} /v ${appName} 2>nul`).toString();
+      return output.includes(appName);
+    } else if (process.platform === 'darwin') {
+      return app.getLoginItemSettings().openAtLogin;
+    } else if (process.platform === 'linux') {
+      const desktopFilePath = path.join(os.homedir(), '.config', 'autostart', `${app.getName()}.desktop`);
+      return fs.existsSync(desktopFilePath);
+    }
+    
+    return false;
+  } catch (error) {
+    // If command fails (e.g., key doesn't exist), auto launch is not enabled
+    return false;
+  }
+}
+
 /**
  * Creates the main application window
  */
@@ -29,8 +165,8 @@ function createWindow(): BrowserWindow {
     frame: false,
     fullscreenable: false,
     autoHideMenuBar: true,
-    minWidth: 700,
-    minHeight: 1000,
+    minWidth: 800,
+    minHeight: 700,
     webPreferences: {
       preload: path.join(__dirname, 'preload.js'),
       contextIsolation: true,
@@ -180,14 +316,66 @@ function createWindow(): BrowserWindow {
 
   // Close application
   ipcMain.on('close-app', () => {
-    app.quit();
+    if (closeToTray) {
+      win?.hide();
+      win?.setSkipTaskbar(true);
+    } else {
+      app.quit();
+    }
   });
 
   // Open URL in default browser
   ipcMain.on('open-url', (event, url) => {
     shell.openExternal(url);
   });
 
+  // Auto-startup handlers
+  ipcMain.handle('get-auto-launch', () => {
+    return getAutoLaunchEnabled();
+  });
+
+  ipcMain.handle('set-auto-launch', (event, enable) => {
+    return setAutoLaunch(enable);
+  });
+
+  // Tray handlers
+  ipcMain.handle('set-close-to-tray', (event, enable) => {
+    closeToTray = enable;
+    return true;
+  });
+
+  ipcMain.handle('get-close-to-tray', () => {
+    return closeToTray;
+  });
+
+  ipcMain.handle('set-startup-to-tray', (event, enable) => {
+    // Store this preference for the next app start
+    try {
+      const configPath = path.join(app.getPath('userData'), 'config.json');
+      let config = {};
+      
+      if (fs.existsSync(configPath)) {
+        config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+      }
+      
+      config = { ...config, startupToTray: enable };
+      fs.writeFileSync(configPath, JSON.stringify(config));
+      return true;
+    } catch (error) {
+      console.error('Error saving startup to tray setting:', error);
+      return false;
+    }
+  });
+
+  // Listen for window close event
+  win.on('close', (e) => {
+    if (closeToTray) {
+      e.preventDefault();
+      win?.hide();
+      win?.setSkipTaskbar(true);
+    }
+  });
+
   // Disable page refresh in production
   if (process.env.NODE_ENV === 'production') {
     win.webContents.on('before-input-event', (event, input) => {
@@ -293,7 +481,28 @@ try {
   // Initialize app when Electron is ready
   // Added delay to fix black background issue with transparent windows
   // See: https://github.com/electron/electron/issues/15947
-  app.on('ready', () => setTimeout(createWindow, 400));
+  app.on('ready', () => {
+    setTimeout(() => {
+      // Create window
+      win = createWindow();
+      
+      // Create tray
+      createTray();
+      
+      // Check if we should start minimized to tray
+      try {
+        const configPath = path.join(app.getPath('userData'), 'config.json');
+        if (fs.existsSync(configPath)) {
+          const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+          if (config.startupToTray) {
+            win.hide();
+          }
+        }
+      } catch (error) {
+        console.error('Error reading config file:', error);
+      }
+    }, 400);
+  });
 
   // Quit when all windows are closed
   app.on('window-all-closed', () => {
@@ -303,7 +512,10 @@ try {
   // Re-create window if activated and no windows exist
   app.on('activate', () => {
     if (win === null) {
-      createWindow();
+      win = createWindow();
+    } else {
+      win.show();
+      win.setSkipTaskbar(false); // Show in taskbar
     }
   });
 } catch (_e) {

app/preload.ts

@@ -29,4 +29,11 @@ contextBridge.exposeInMainWorld('electron', {
   saveFile: (fileBuffer: ArrayBuffer | string, fileName: string, fileType: string) => 
     ipcRenderer.invoke('save-file', { fileBuffer, fileName, fileType }),
   openFile: (filePath: string) => ipcRenderer.invoke('open-file', filePath),
+  
+  // Auto-startup and tray functions
+  getAutoLaunch: () => ipcRenderer.invoke('get-auto-launch'),
+  setAutoLaunch: (enable: boolean) => ipcRenderer.invoke('set-auto-launch', enable),
+  setCloseToTray: (enable: boolean) => ipcRenderer.invoke('set-close-to-tray', enable),
+  getCloseToTray: () => ipcRenderer.invoke('get-close-to-tray'),
+  setStartupToTray: (enable: boolean) => ipcRenderer.invoke('set-startup-to-tray', enable),
 }); 

src/components/pages/SettingsPage.tsx

@@ -65,13 +65,31 @@ export const SettingsPage: React.FC<SettingsPageProps> = ({
       setHasApiKeyChanged(false);
       lastOpenedSettings.current = true;
 
-      // In a real implementation, we would load these from settings service
-      // This is just for the UI prototype
-      // setStartWithSystem(settings.startWithSystem || false);
-      // setStartupToTray(settings.startupToTray || false);
-      // setCloseToTray(settings.closeToTray || true);
-      // setProxyMode(settings.proxyMode || 'system');
-      // setSendErrorReports(settings.sendErrorReports || true);
+      // Load general settings from settings service
+      setStartWithSystem(settings.startWithSystem || false);
+      setStartupToTray(settings.startupToTray || false);
+      setCloseToTray(settings.closeToTray || true);
+      setProxyMode(settings.proxyMode || 'system');
+      setSendErrorReports(settings.sendErrorReports || true);
+      
+      // Load current auto-start setting from system
+      const checkAutoLaunch = async () => {
+        if (window.electron && window.electron.getAutoLaunch) {
+          const autoLaunchEnabled = await window.electron.getAutoLaunch();
+          setStartWithSystem(autoLaunchEnabled);
+        }
+      };
+      
+      // Load current close-to-tray setting
+      const checkCloseToTray = async () => {
+        if (window.electron && window.electron.getCloseToTray) {
+          const closeToTrayEnabled = await window.electron.getCloseToTray();
+          setCloseToTray(closeToTrayEnabled);
+        }
+      };
+      
+      checkAutoLaunch();
+      checkCloseToTray();
     }
 
     if(!isOpen && lastOpenedSettings.current){
@@ -117,12 +135,24 @@ export const SettingsPage: React.FC<SettingsPageProps> = ({
     switch(key) {
       case 'startWithSystem':
         setStartWithSystem(value as boolean);
+        // Apply auto-launch setting to system
+        if (window.electron && window.electron.setAutoLaunch) {
+          window.electron.setAutoLaunch(value as boolean);
+        }
         break;
       case 'startupToTray':
         setStartupToTray(value as boolean);
+        // Store startup-to-tray setting
+        if (window.electron && window.electron.setStartupToTray) {
+          window.electron.setStartupToTray(value as boolean);
+        }
         break;
       case 'closeToTray':
         setCloseToTray(value as boolean);
+        // Apply close-to-tray setting
+        if (window.electron && window.electron.setCloseToTray) {
+          window.electron.setCloseToTray(value as boolean);
+        }
         break;
       case 'proxyMode':
         setProxyMode(value as 'system' | 'custom' | 'none');
@@ -150,13 +180,13 @@ export const SettingsPage: React.FC<SettingsPageProps> = ({
       // Update all settings in one go
       await settingsService.updateSettings({
         providers: providerSettings,
-        enableWebSearch_Preview: useWebSearch
-        // In a real implementation, we would save general settings here
-        // startWithSystem,
-        // startupToTray,
-        // closeToTray,
-        // proxyMode,
-        // sendErrorReports
+        enableWebSearch_Preview: useWebSearch,
+        // Save general settings
+        startWithSystem,
+        startupToTray,
+        closeToTray,
+        proxyMode,
+        sendErrorReports
       });
 
       // Refresh models if API key has changed

src/components/settings/GeneralSettings.tsx

@@ -1,4 +1,4 @@
-import React, { useState } from 'react';
+import React, { useState, useEffect } from 'react';
 import { useTranslation } from 'react-i18next';
 
 interface GeneralSettingsProps {
@@ -22,6 +22,19 @@ export const GeneralSettings: React.FC<GeneralSettingsProps> = ({
 }) => {
   const { t } = useTranslation();
   const [customProxyUrl, setCustomProxyUrl] = useState<string>('');
+  const [isWindows, setIsWindows] = useState(false);
+  
+  // Check if running on Windows platform
+  useEffect(() => {
+    const checkPlatform = async () => {
+      if (window.electron && window.electron.getPlatform) {
+        const platform = await window.electron.getPlatform();
+        setIsWindows(platform === 'win32');
+      }
+    };
+    
+    checkPlatform();
+  }, []);
 
   const handleProxyModeChange = (mode: 'system' | 'custom' | 'none') => {
     onSettingChange('proxyMode', mode);