feat: add user setting for update notification interval

src/main/index.ts

@@ -2,7 +2,10 @@ import { app } from 'electron';
 import log from 'electron-log';
 import { menubar } from 'menubar';
 
+import { EVENTS } from '../shared/events';
+
 import { Paths, WindowConfig } from './config';
+import { onMainEvent } from './events';
 import {
   registerAppHandlers,
   registerStorageHandlers,
@@ -43,6 +46,13 @@ app.setAsDefaultProtocolClient(protocol);
 
 const appUpdater = new AppUpdater(mb, menuBuilder);
 
+// Keep update-prompt quiet frequency in sync with renderer settings.
+onMainEvent(EVENTS.UPDATE_PROMPT_QUIET_FREQUENCY, (_, frequency: string) => {
+  appUpdater.setUpdatePromptQuietFrequency(
+    frequency as 'DAILY' | 'WEEKLY' | 'MONTHLY' | 'NEVER',
+  );
+});
+
 app.whenReady().then(async () => {
   await onFirstRunMaybe();
 

src/main/updater.test.ts

@@ -1,3 +1,6 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
 import { dialog } from 'electron';
 import type { Menubar } from 'menubar';
 
@@ -33,6 +36,8 @@ vi.mock('electron-updater', () => ({
   },
 }));
 
+const userDataPath = path.join(process.cwd(), '.gitify-test-userdata');
+
 // Mock electron (dialog + basic Menu API used by MenuBuilder constructor)
 vi.mock('electron', () => {
   class MenuItem {
@@ -41,6 +46,7 @@ vi.mock('electron', () => {
     }
   }
   return {
+    app: { getPath: vi.fn(() => userDataPath) },
     dialog: { showMessageBox: vi.fn() },
     MenuItem,
     Menu: { buildFromTemplate: vi.fn() },
@@ -76,6 +82,13 @@ describe('main/updater.ts', () => {
       delete listeners[k];
     }
 
+    try {
+      fs.mkdirSync(userDataPath, { recursive: true });
+      fs.unlinkSync(path.join(userDataPath, 'update-prompt-quiet.json'));
+    } catch {
+      // Ignore: missing state file is expected for fresh tests.
+    }
+
     menubar = {
       app: {
         isPackaged: true,

src/main/updater.ts

@@ -1,4 +1,7 @@
-import { dialog, type MessageBoxOptions } from 'electron';
+import fs from 'node:fs';
+import path from 'node:path';
+
+import { app, dialog, type MessageBoxOptions } from 'electron';
 import { autoUpdater } from 'electron-updater';
 import type { Menubar } from 'menubar';
 
@@ -7,6 +10,19 @@ import { logError, logInfo } from '../shared/logger';
 
 import type MenuBuilder from './menu';
 
+type UpdatePromptQuietFrequency = 'DAILY' | 'WEEKLY' | 'MONTHLY' | 'NEVER';
+
+const UPDATE_PROMPT_QUIET_STATE_FILE = 'update-prompt-quiet.json';
+
+const UPDATE_PROMPT_QUIET_WINDOW_MS: Record<
+  Exclude<UpdatePromptQuietFrequency, 'NEVER'>,
+  number
+> = {
+  DAILY: 24 * 60 * 60 * 1000,
+  WEEKLY: 7 * 24 * 60 * 60 * 1000,
+  MONTHLY: 30 * 24 * 60 * 60 * 1000,
+};
+
 /**
  * Updater class for handling application updates.
  *
@@ -23,9 +39,21 @@ export default class AppUpdater {
   private noUpdateMessageTimeout?: NodeJS.Timeout;
   private periodicInterval?: NodeJS.Timeout;
 
+  private updatePromptQuietFrequency: UpdatePromptQuietFrequency = 'DAILY';
+  private lastUpdatePromptAtMs?: number;
+  private readonly quietStatePath: string;
+
   constructor(menubar: Menubar, menuBuilder: MenuBuilder) {
     this.menubar = menubar;
     this.menuBuilder = menuBuilder;
+
+    this.quietStatePath = path.join(
+      app.getPath('userData'),
+      UPDATE_PROMPT_QUIET_STATE_FILE,
+    );
+
+    this.loadUpdatePromptQuietState();
+
     // Disable electron-updater's own logging to avoid duplicate log messages
     // We'll handle all logging through our event listeners
     autoUpdater.logger = null;
@@ -87,7 +115,7 @@ export default class AppUpdater {
       this.setTooltipWithStatus('A new update is ready to install');
       this.menuBuilder.setUpdateAvailableMenuVisibility(false);
       this.menuBuilder.setUpdateReadyForInstallMenuVisibility(true);
-      this.showUpdateReadyDialog(event.releaseName);
+      void this.maybeShowUpdateReadyDialog(event.releaseName);
     });
 
     autoUpdater.on('update-not-available', () => {
@@ -115,6 +143,111 @@ export default class AppUpdater {
     });
   }
 
+  /**
+   * Update how often we show the update-ready dialog.
+   * This controls only the dialog frequency, not the update check/download behavior.
+   */
+  public setUpdatePromptQuietFrequency(
+    frequency: UpdatePromptQuietFrequency,
+  ): void {
+    if (
+      frequency !== 'DAILY' &&
+      frequency !== 'WEEKLY' &&
+      frequency !== 'MONTHLY' &&
+      frequency !== 'NEVER'
+    ) {
+      return;
+    }
+
+    this.updatePromptQuietFrequency = frequency;
+    this.persistUpdatePromptQuietState();
+  }
+
+  private loadUpdatePromptQuietState(): void {
+    try {
+      const raw = fs.readFileSync(this.quietStatePath, 'utf8');
+      const parsed = JSON.parse(raw) as {
+        updatePromptQuietFrequency?: UpdatePromptQuietFrequency;
+        lastUpdatePromptAtMs?: number;
+      };
+
+      if (
+        parsed.updatePromptQuietFrequency === 'DAILY' ||
+        parsed.updatePromptQuietFrequency === 'WEEKLY' ||
+        parsed.updatePromptQuietFrequency === 'MONTHLY' ||
+        parsed.updatePromptQuietFrequency === 'NEVER'
+      ) {
+        this.updatePromptQuietFrequency = parsed.updatePromptQuietFrequency;
+      }
+
+      if (
+        typeof parsed.lastUpdatePromptAtMs === 'number' &&
+        Number.isFinite(parsed.lastUpdatePromptAtMs)
+      ) {
+        this.lastUpdatePromptAtMs = parsed.lastUpdatePromptAtMs;
+      }
+    } catch {
+      // Best-effort persistence: missing/invalid state should not break app updates.
+    }
+  }
+
+  private persistUpdatePromptQuietState(): void {
+    try {
+      fs.writeFileSync(
+        this.quietStatePath,
+        JSON.stringify(
+          {
+            updatePromptQuietFrequency: this.updatePromptQuietFrequency,
+            lastUpdatePromptAtMs: this.lastUpdatePromptAtMs,
+          },
+          null,
+          0,
+        ),
+        'utf8',
+      );
+    } catch {
+      // Ignore persistence errors — update prompting should still work.
+    }
+  }
+
+  private getQuietWindowMs(
+    frequency: UpdatePromptQuietFrequency,
+  ): number | null {
+    if (frequency === 'NEVER') {
+      return null;
+    }
+
+    return UPDATE_PROMPT_QUIET_WINDOW_MS[
+      frequency as Exclude<UpdatePromptQuietFrequency, 'NEVER'>
+    ];
+  }
+
+  private async maybeShowUpdateReadyDialog(releaseName: string) {
+    const quietWindowMs = this.getQuietWindowMs(
+      this.updatePromptQuietFrequency,
+    );
+
+    // NEVER means: never show dialog.
+    if (quietWindowMs === null) {
+      return;
+    }
+
+    const now = Date.now();
+
+    // Global quiet-scope: only show once per window.
+    if (
+      this.lastUpdatePromptAtMs !== undefined &&
+      now - this.lastUpdatePromptAtMs < quietWindowMs
+    ) {
+      logInfo('app updater', 'Quiet prompt window active; skipping dialog');
+      return;
+    }
+
+    this.lastUpdatePromptAtMs = now;
+    this.persistUpdatePromptQuietState();
+    this.showUpdateReadyDialog(releaseName);
+  }
+
   /**
    * Run an immediate update check on application launch.
    */

src/preload/index.ts

@@ -161,6 +161,18 @@ export const api = {
     },
   },
 
+  /** Application update prompt controls. */
+  updates: {
+    /**
+     * Set how often Gitify shows the “Application Update / Restart / Later” dialog
+     * after downloading an update.
+     *
+     * @param frequency - One of: DAILY | WEEKLY | MONTHLY | NEVER
+     */
+    setUpdatePromptQuietFrequency: (frequency: string) =>
+      sendMainEvent(EVENTS.UPDATE_PROMPT_QUIET_FREQUENCY, frequency),
+  },
+
   /** Electron web frame zoom controls. */
   zoom: {
     /**

src/renderer/__helpers__/vitest.setup.ts

@@ -32,6 +32,9 @@ window.gitify = {
     quit: vi.fn(),
     show: vi.fn(),
   },
+  updates: {
+    setUpdatePromptQuietFrequency: vi.fn(),
+  },
   twemojiDirectory: vi.fn().mockResolvedValue('/mock/images/assets'),
   openExternalLink: vi.fn(),
   decryptValue: vi.fn().mockResolvedValue('decrypted'),

src/renderer/__mocks__/state-mocks.ts

@@ -14,6 +14,7 @@ import {
   Theme,
   type Token,
   type TraySettingsState,
+  UpdatePromptQuietFrequency,
 } from '../types';
 
 import {
@@ -48,6 +49,7 @@ const mockNotificationSettings: NotificationSettingsState = {
   markAsDoneOnOpen: false,
   markAsDoneOnUnsubscribe: false,
   delayNotificationState: false,
+  updatePromptQuietFrequency: UpdatePromptQuietFrequency.DAILY,
 };
 
 const mockTraySettings: TraySettingsState = {

src/renderer/components/settings/NotificationSettings.test.tsx

@@ -42,6 +42,25 @@ describe('renderer/components/settings/NotificationSettings.tsx', () => {
     expect(updateSettingMock).toHaveBeenCalledWith('fetchType', 'INACTIVITY');
   });
 
+  it('should update update prompt quiet frequency with dropdown', async () => {
+    await act(async () => {
+      renderWithAppContext(<NotificationSettings />, {
+        updateSetting: updateSettingMock,
+      });
+    });
+
+    await userEvent.selectOptions(
+      screen.getByTestId('settings-update-prompt-quiet-frequency'),
+      'WEEKLY',
+    );
+
+    expect(updateSettingMock).toHaveBeenCalledTimes(1);
+    expect(updateSettingMock).toHaveBeenCalledWith(
+      'updatePromptQuietFrequency',
+      'WEEKLY',
+    );
+  });
+
   describe('fetch interval settings', () => {
     it('should update the fetch interval values when using the buttons', async () => {
       await act(async () => {