Hide ComfyUI instead of quitting when window is closed

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.
+ * Closes the application or 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.verbose('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 @@ describe('ComfySettings', () => {
       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',

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 { ComfySettings, 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,129 @@ 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(async () => {
+      await ComfySettings.load('/test/path');
+      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(async () => {
+      await ComfySettings.load('/test/path');
+      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));
+    });
+  });
+});