Hide ComfyUI instead of quitting when window is closed

src/config/comfySettings.ts

@@ -5,6 +5,7 @@
 export const DEFAULT_SETTINGS: ComfySettingsData = {
   'Comfy-Desktop.AutoUpdate': true,
   'Comfy-Desktop.SendStatistics': true,
+  'Comfy-Desktop.RunInBackgroundOnClose': false,
   'Comfy.ColorPalette': 'dark',
   'Comfy.UseNewMenu': 'Top',
   'Comfy.Workflow.WorkflowTabsPosition': 'Topbar',
@@ -18,6 +19,7 @@
 export interface ComfySettingsData {
   'Comfy-Desktop.AutoUpdate': boolean;
   'Comfy-Desktop.SendStatistics': boolean;
+  'Comfy-Desktop.RunInBackgroundOnClose': boolean;
   'Comfy.ColorPalette': 'dark' | 'light';
   'Comfy.UseNewMenu': 'Top' | 'Bottom';
   'Comfy.Workflow.WorkflowTabsPosition': 'Topbar' | 'Sidebar';
@@ -135,7 +137,7 @@
     }
 
     try {
       await fs.writeFile(this.filePath, JSON.stringify(this.settings, null, 2));
     } catch (error) {
       log.error('Failed to save settings:', error);
       throw error;

src/main-process/appWindow.ts

@@ -17,6 +17,7 @@ import { debounce } from 'lodash';
 import path from 'node:path';
 import { URL } from 'node:url';
 
+import { useComfySettings } from '@/config/comfySettings';
 import { ElectronError } from '@/infrastructure/electronError';
 import type { Page } from '@/infrastructure/interfaces';
 import { type IAppState, useAppState } from '@/main-process/appState';
@@ -30,7 +31,7 @@ import { useDesktopConfig } from '../store/desktopConfig';
 
 /**
  * Creates a single application window that displays the renderer and encapsulates all the logic for sending messages to the renderer.
- * Closes the application when the window is closed.
+ * Conditionally hides to system tray when the window is closed (based on 'Comfy-Desktop.RunInBackgroundOnClose' setting).
  */
 export class AppWindow {
   private readonly appState: IAppState = useAppState();
@@ -170,10 +171,18 @@ export class AppWindow {
 
   public show(): void {
     this.window.show();
+    if (process.platform === 'darwin') {
+      app.dock.show().catch((error) => {
+        log.error('Error showing dock', error);
+      });
+    }
   }
 
   public hide(): void {
     this.window.hide();
+    if (process.platform === 'darwin') {
+      app.dock.hide();
+    }
   }
 
   public isMinimized(): boolean {
@@ -318,7 +327,28 @@ export class AppWindow {
 
     this.window.on('resize', updateBounds);
     this.window.on('move', updateBounds);
-    this.window.on('close', () => log.info('App window closed.'));
+    this.window.on('close', (event) => {
+      if (this.appState.isQuitting) {
+        // App is actually quitting - allow the window to close
+        log.info('App window closing - app is quitting');
+        return;
+      }
+
+      // Check if run in background setting is enabled
+      const settings = useComfySettings();
+      const runInBackground = settings.get('Comfy-Desktop.RunInBackgroundOnClose');
+
+      if (runInBackground) {
+        // Hide to tray - prevent window close
+        log.info('App window close requested - hiding to tray instead');
+        event.preventDefault();
+        this.hide();
+      } else {
+        // Setting is disabled - allow normal close behavior (quit app)
+        log.info('App window closing - run in background disabled');
+        // Let the window close normally, which will quit the app
+      }
+    });
 
     this.window.webContents.setWindowOpenHandler(({ url }) => {
       if (this.#shouldOpenInPopup(url)) {
@@ -343,6 +373,11 @@ export class AppWindow {
       if (this.isMinimized()) this.restore();
       this.focus();
     });
+
+    // Handle activate event (macOS - clicking dock icon when no windows visible)
+    app.on('activate', () => {
+      this.show();
+    });
   }
 
   private setupIpcEvents() {
@@ -418,12 +453,6 @@ export class AppWindow {
         label: 'Show Comfy Window',
         click: () => {
           this.show();
-          // Mac Only
-          if (process.platform === 'darwin') {
-            app.dock.show().catch((error) => {
-              log.error('Error showing dock', error);
-            });
-          }
         },
       },
       {
@@ -436,10 +465,6 @@ export class AppWindow {
         label: 'Hide',
         click: () => {
           this.hide();
-          // Mac Only
-          if (process.platform === 'darwin') {
-            app.dock.hide();
-          }
         },
       },
     ]);

src/main.ts

@@ -4,6 +4,7 @@ import { app, session, shell } from 'electron';
 import { LevelOption } from 'electron-log';
 import log from 'electron-log/main';
 
+import { useComfySettings } from './config/comfySettings';
 import { LogFile } from './constants';
 import { DesktopApp } from './desktopApp';
 import { removeAnsiCodesTransform, replaceFileLoggingTransform } from './infrastructure/structuredLogging';
@@ -23,7 +24,7 @@ initializeAppState();
 const overrides = new DevOverrides();
 
 // Register the quit handlers regardless of single instance lock and before squirrel startup events.
-quitWhenAllWindowsAreClosed();
+maybeQuitWhenAllWindowsAreClosed();
 trackAppQuitEvents();
 initializeSentry();
 
@@ -89,10 +90,24 @@ function initalizeLogging() {
   log.info(`Starting app v${app.getVersion()}`);
 }
 
-/** Quit when all windows are closed.*/
-function quitWhenAllWindowsAreClosed() {
+/** Quit when all windows are closed, unless run in background setting is enabled.*/
+function maybeQuitWhenAllWindowsAreClosed() {
   app.on('window-all-closed', () => {
-    log.info('Quitting ComfyUI because window all closed');
+    try {
+      // Check if run in background setting is enabled
+      const settings = useComfySettings();
+      const runInBackground = settings.get('Comfy-Desktop.RunInBackgroundOnClose');
+
+      if (runInBackground) {
+        log.info('All windows closed but keeping app running in background');
+        return; // Don't quit, keep running in background
+      }
+    } catch (error) {
+      // Settings not loaded yet or other error - fall back to default behavior (quit)
+      log.warn('Could not check RunInBackgroundOnClose setting, defaulting to quit:', error);
+    }
+
+    log.info('Quitting ComfyUI because all windows closed');
     app.quit();
   });
 }

tests/unit/config/comfySettings.test.ts

@@ -82,6 +82,7 @@
       const mockSettings: ComfySettingsData = {
         'Comfy-Desktop.AutoUpdate': false,
         'Comfy-Desktop.SendStatistics': false,
+        'Comfy-Desktop.RunInBackgroundOnClose': true,
         'Comfy.ColorPalette': 'dark',
         'Comfy.UseNewMenu': 'Top',
         'Comfy.Workflow.WorkflowTabsPosition': 'Topbar',
@@ -96,7 +97,7 @@
       vi.mocked(fsPromises.readFile).mockResolvedValue(JSON.stringify(mockSettings));
 
       settings = await ComfySettings.load(basePath);
       expect(settings.get('Comfy-Desktop.AutoUpdate')).toBe(false);
       expect(settings.get('Comfy.Server.LaunchArgs')).toEqual({ test: 'value' });
       expect(settings.get('Comfy-Desktop.SendStatistics')).toBe(false);
     });
@@ -125,7 +126,7 @@
 
       settings = await ComfySettings.load(basePath);
       expect(settings.get('Comfy-Desktop.AutoUpdate')).toBe(DEFAULT_SETTINGS['Comfy-Desktop.AutoUpdate']);
       expect(log.error).toHaveBeenCalled();
     });
   });
 
@@ -169,7 +170,7 @@
 
     it('should throw error on write error during saveSettings', async () => {
       vi.mocked(fsPromises.writeFile).mockRejectedValue(new Error('Permission denied'));
       await expect(settings.saveSettings()).rejects.toThrow('Permission denied');
     });
   });
 

tests/unit/handlers/pathHandler.test.ts

@@ -87,7 +87,7 @@ const mockFileSystem = ({ exists = true, writable = true, isDirectory = false, c
     isDirectory: () => isDirectory,
   } as unknown as fs.Stats);
   vi.mocked(fs.readdirSync).mockReturnValue(
-    Array.from({ length: contentLength }, () => ({ name: 'mock-file' }) as fs.Dirent)
+    Array.from({ length: contentLength }, () => ({ name: 'mock-file' }) as any)
   );
   if (writable) {
     vi.mocked(fs.accessSync).mockReturnValue();

tests/unit/main-process/appWindow.test.ts

@@ -1,10 +1,19 @@
 import { BrowserWindow, type Tray } from 'electron';
 import { beforeEach, describe, expect, it, vi } from 'vitest';
 
+import { useComfySettings } from '@/config/comfySettings';
 import { AppWindow } from '@/main-process/appWindow';
 
 import { type PartialMock, electronMock } from '../setup';
 
+const mockAppState = {
+  isQuitting: false,
+};
+
+vi.mock('@/main-process/appState', () => ({
+  useAppState: vi.fn(() => mockAppState),
+}));
+
 const additionalMocks: PartialMock<typeof Electron> = {
   BrowserWindow: vi.fn() as PartialMock<BrowserWindow>,
   nativeTheme: {
@@ -107,3 +116,127 @@ describe('AppWindow.isOnPage', () => {
     expect(appWindow.isOnPage('welcome')).toBe(true);
   });
 });
+
+describe('AppWindow tray behavior', () => {
+  let mockWindow: PartialMock<BrowserWindow>;
+  let windowCloseHandler: (event: Electron.Event) => void;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockAppState.isQuitting = false;
+
+    mockWindow = {
+      show: vi.fn(),
+      hide: vi.fn(),
+      on: vi.fn((event: string, handler: any) => {
+        if (event === 'close') windowCloseHandler = handler;
+      }),
+      once: vi.fn(),
+      webContents: { getURL: vi.fn(), setWindowOpenHandler: vi.fn() },
+    };
+
+    vi.mocked(BrowserWindow).mockImplementation(() => mockWindow as BrowserWindow);
+  });
+
+  describe('when RunInBackgroundOnClose is enabled', () => {
+    beforeEach(() => {
+      const settings = useComfySettings();
+      settings.set('Comfy-Desktop.RunInBackgroundOnClose', true);
+    });
+
+    it('should hide to tray when window closed and app not quitting', () => {
+      vi.stubGlobal('process', { ...process, platform: 'win32', resourcesPath: '/mock' });
+      new AppWindow();
+      const mockEvent = { preventDefault: vi.fn() };
+
+      windowCloseHandler(mockEvent as any);
+
+      expect(mockEvent.preventDefault).toHaveBeenCalled();
+      expect(mockWindow.hide).toHaveBeenCalled();
+    });
+
+    it('should still allow window close when app is quitting', () => {
+      vi.stubGlobal('process', { ...process, platform: 'win32', resourcesPath: '/mock' });
+      mockAppState.isQuitting = true;
+      new AppWindow();
+      const mockEvent = { preventDefault: vi.fn() };
+
+      windowCloseHandler(mockEvent as any);
+
+      expect(mockEvent.preventDefault).not.toHaveBeenCalled();
+      expect(mockWindow.hide).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('when RunInBackgroundOnClose is disabled (default)', () => {
+    beforeEach(() => {
+      const settings = useComfySettings();
+      settings.set('Comfy-Desktop.RunInBackgroundOnClose', false);
+    });
+
+    it('should allow window to close normally', () => {
+      vi.stubGlobal('process', { ...process, platform: 'win32', resourcesPath: '/mock' });
+      new AppWindow();
+      const mockEvent = { preventDefault: vi.fn() };
+
+      windowCloseHandler(mockEvent as any);
+
+      expect(mockEvent.preventDefault).not.toHaveBeenCalled();
+      expect(mockWindow.hide).not.toHaveBeenCalled();
+    });
+
+    it('should allow window close when app is quitting', () => {
+      vi.stubGlobal('process', { ...process, platform: 'win32', resourcesPath: '/mock' });
+      mockAppState.isQuitting = true;
+      new AppWindow();
+      const mockEvent = { preventDefault: vi.fn() };
+
+      windowCloseHandler(mockEvent as any);
+
+      expect(mockEvent.preventDefault).not.toHaveBeenCalled();
+      expect(mockWindow.hide).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('macOS dock behavior', () => {
+    beforeEach(() => {
+      vi.stubGlobal('process', { ...process, platform: 'darwin', resourcesPath: '/mock' });
+      electronMock.app.dock = {
+        show: vi.fn().mockResolvedValue(undefined),
+        hide: vi.fn(),
+        bounce: vi.fn(),
+        cancelBounce: vi.fn(),
+        downloadFinished: vi.fn(),
+        getBadge: vi.fn(),
+        setBadge: vi.fn(),
+        getMenu: vi.fn(),
+        setMenu: vi.fn(),
+        setIcon: vi.fn(),
+      } as any;
+    });
+
+    it('should hide dock when hiding window on macOS', () => {
+      const appWindow = new AppWindow();
+
+      appWindow.hide();
+
+      expect(mockWindow.hide).toHaveBeenCalled();
+      expect(electronMock.app.dock?.hide).toHaveBeenCalled();
+    });
+
+    it('should show dock when showing window on macOS', () => {
+      const appWindow = new AppWindow();
+
+      appWindow.show();
+
+      expect(mockWindow.show).toHaveBeenCalled();
+      expect(electronMock.app.dock?.show).toHaveBeenCalled();
+    });
+
+    it('should register activate handler for dock clicks on macOS', () => {
+      new AppWindow();
+
+      expect(electronMock.app.on).toHaveBeenCalledWith('activate', expect.any(Function));
+    });
+  });
+});

tests/unit/setup.ts

@@ -1,7 +1,8 @@
 import type { FileTransport, MainLogger, MainTransports } from 'electron-log';
 import log from 'electron-log/main';
-import { vi } from 'vitest';
+import { beforeEach, vi } from 'vitest';
 
+import { ComfySettings } from '@/config/comfySettings';
 import type { IAppState } from '@/main-process/appState';
 import type { ITelemetry } from '@/services/telemetry';
 
@@ -45,6 +46,18 @@ export const electronMock: ElectronMock = {
     getVersion: vi.fn(() => '1.0.0'),
     on: vi.fn(),
     once: vi.fn(),
+    dock: {
+      show: vi.fn().mockResolvedValue(undefined),
+      hide: vi.fn(),
+      bounce: vi.fn(),
+      cancelBounce: vi.fn(),
+      downloadFinished: vi.fn(),
+      getBadge: vi.fn(),
+      setBadge: vi.fn(),
+      getMenu: vi.fn(),
+      setMenu: vi.fn(),
+      setIcon: vi.fn(),
+    } as any,
   },
   dialog: {
     showErrorBox: vi.fn(),
@@ -95,3 +108,8 @@ vi.mock('@/services/telemetry', async () => {
     promptMetricsConsent: vi.fn().mockResolvedValue(true),
   };
 });
+
+// Initialize ComfySettings for tests
+beforeEach(async () => {
+  await ComfySettings.load('/test/path');
+});