refactor(main): extract IPC handlers into dedicated modules (#1720)

* refactor(main): extract IPC handlers into dedicated modules

* test: add basic test for indexes

Author: samuv

main/src/ipc-handlers/__tests__/index.test.ts

@@ -0,0 +1,51 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+
+const mocks = vi.hoisted(() => ({
+  registerApp: vi.fn(),
+  registerAutoUpdate: vi.fn(),
+  registerChat: vi.fn(),
+  registerCli: vi.fn(),
+  registerDarkMode: vi.fn(),
+  registerDialogs: vi.fn(),
+  registerFeatureFlags: vi.fn(),
+  registerTelemetry: vi.fn(),
+  registerToolhive: vi.fn(),
+  registerUtils: vi.fn(),
+  registerWindow: vi.fn(),
+}))
+
+vi.mock('../app', () => ({ register: mocks.registerApp }))
+vi.mock('../auto-update', () => ({ register: mocks.registerAutoUpdate }))
+vi.mock('../chat', () => ({ register: mocks.registerChat }))
+vi.mock('../cli', () => ({ register: mocks.registerCli }))
+vi.mock('../dark-mode', () => ({ register: mocks.registerDarkMode }))
+vi.mock('../dialogs', () => ({ register: mocks.registerDialogs }))
+vi.mock('../feature-flags', () => ({ register: mocks.registerFeatureFlags }))
+vi.mock('../telemetry', () => ({ register: mocks.registerTelemetry }))
+vi.mock('../toolhive', () => ({ register: mocks.registerToolhive }))
+vi.mock('../utils', () => ({ register: mocks.registerUtils }))
+vi.mock('../window', () => ({ register: mocks.registerWindow }))
+
+import { registerAllHandlers } from '../index'
+
+describe('registerAllHandlers', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+  })
+
+  it('calls every handler registration function exactly once', () => {
+    registerAllHandlers()
+
+    expect(mocks.registerApp).toHaveBeenCalledOnce()
+    expect(mocks.registerAutoUpdate).toHaveBeenCalledOnce()
+    expect(mocks.registerChat).toHaveBeenCalledOnce()
+    expect(mocks.registerCli).toHaveBeenCalledOnce()
+    expect(mocks.registerDarkMode).toHaveBeenCalledOnce()
+    expect(mocks.registerDialogs).toHaveBeenCalledOnce()
+    expect(mocks.registerFeatureFlags).toHaveBeenCalledOnce()
+    expect(mocks.registerTelemetry).toHaveBeenCalledOnce()
+    expect(mocks.registerToolhive).toHaveBeenCalledOnce()
+    expect(mocks.registerUtils).toHaveBeenCalledOnce()
+    expect(mocks.registerWindow).toHaveBeenCalledOnce()
+  })
+})

main/src/ipc-handlers/app.ts

@@ -0,0 +1,77 @@
+import { app, ipcMain } from 'electron'
+import { existsSync, readFile } from 'node:fs'
+import path from 'node:path'
+import { blockQuit } from '../app-events'
+import { setAutoLaunch, getAutoLaunchStatus } from '../auto-launch'
+import { showInDock } from '../dock-utils'
+import log from '../logger'
+import { showMainWindow, hideMainWindow } from '../main-window'
+import { createApplicationMenu } from '../menu'
+import {
+  getSkipQuitConfirmation,
+  setSkipQuitConfirmation,
+} from '../quit-confirmation'
+import { updateTrayStatus } from '../system-tray'
+import { isToolhiveRunning } from '../toolhive-manager'
+
+export function register() {
+  ipcMain.handle('get-auto-launch-status', () => getAutoLaunchStatus())
+
+  ipcMain.handle('set-auto-launch', (_event, enabled: boolean) => {
+    setAutoLaunch(enabled)
+    updateTrayStatus(isToolhiveRunning())
+    createApplicationMenu()
+    return getAutoLaunchStatus()
+  })
+
+  ipcMain.handle('show-app', async () => {
+    try {
+      showInDock()
+      await showMainWindow()
+    } catch (error) {
+      log.error('Failed to show app:', error)
+    }
+  })
+
+  ipcMain.handle('hide-app', () => {
+    try {
+      hideMainWindow()
+    } catch (error) {
+      log.error('Failed to hide app:', error)
+    }
+  })
+
+  ipcMain.handle('quit-app', () => {
+    blockQuit('before-quit')
+  })
+
+  ipcMain.handle('get-skip-quit-confirmation', () => getSkipQuitConfirmation())
+  ipcMain.handle('set-skip-quit-confirmation', (_e, skip: boolean) =>
+    setSkipQuitConfirmation(skip)
+  )
+
+  ipcMain.handle(
+    'get-main-log-content',
+    async (): Promise<string | undefined> => {
+      try {
+        const logPath = path.join(app.getPath('logs'), 'main.log')
+        if (!existsSync(logPath)) {
+          log.warn(`Log file does not exist: ${logPath}`)
+          return
+        }
+
+        const content = await new Promise<string>((resolve, reject) => {
+          readFile(logPath, 'utf8', (err, data) => {
+            if (err) reject(err)
+            else resolve(data)
+          })
+        })
+
+        return content
+      } catch (error) {
+        log.error('Failed to read log file:', error)
+        return
+      }
+    }
+  )
+}

main/src/ipc-handlers/auto-update.ts

@@ -0,0 +1,34 @@
+import { ipcMain } from 'electron'
+import {
+  getIsAutoUpdateEnabled,
+  getLatestAvailableVersion,
+  getUpdateState,
+  manualUpdate,
+  setAutoUpdateEnabled,
+} from '../auto-update'
+import log from '../logger'
+
+export function register() {
+  ipcMain.handle('auto-update:set', async (_, enabled: boolean) => {
+    setAutoUpdateEnabled(enabled)
+    return enabled
+  })
+
+  ipcMain.handle('auto-update:get', () => {
+    return getIsAutoUpdateEnabled()
+  })
+
+  ipcMain.handle('manual-update', async () => {
+    log.info('[update] triggered manual update')
+    manualUpdate()
+  })
+
+  ipcMain.handle('get-app-version', async () => {
+    const versionInfo = await getLatestAvailableVersion()
+    return versionInfo
+  })
+
+  ipcMain.handle('get-update-state', async () => {
+    return getUpdateState()
+  })
+}

main/src/ipc-handlers/chat/__tests__/index.test.ts

@@ -0,0 +1,33 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+
+const mocks = vi.hoisted(() => ({
+  registerMcpTools: vi.fn(),
+  registerProviders: vi.fn(),
+  registerSettings: vi.fn(),
+  registerStreaming: vi.fn(),
+  registerThreads: vi.fn(),
+}))
+
+vi.mock('../mcp-tools', () => ({ register: mocks.registerMcpTools }))
+vi.mock('../providers', () => ({ register: mocks.registerProviders }))
+vi.mock('../settings', () => ({ register: mocks.registerSettings }))
+vi.mock('../streaming', () => ({ register: mocks.registerStreaming }))
+vi.mock('../threads', () => ({ register: mocks.registerThreads }))
+
+import { register } from '../index'
+
+describe('chat register', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+  })
+
+  it('calls every chat handler registration function exactly once', () => {
+    register()
+
+    expect(mocks.registerProviders).toHaveBeenCalledOnce()
+    expect(mocks.registerStreaming).toHaveBeenCalledOnce()
+    expect(mocks.registerSettings).toHaveBeenCalledOnce()
+    expect(mocks.registerMcpTools).toHaveBeenCalledOnce()
+    expect(mocks.registerThreads).toHaveBeenCalledOnce()
+  })
+})

main/src/ipc-handlers/chat/index.ts

@@ -0,0 +1,13 @@
+import { register as registerMcpTools } from './mcp-tools'
+import { register as registerProviders } from './providers'
+import { register as registerSettings } from './settings'
+import { register as registerStreaming } from './streaming'
+import { register as registerThreads } from './threads'
+
+export function register() {
+  registerProviders()
+  registerStreaming()
+  registerSettings()
+  registerMcpTools()
+  registerThreads()
+}

main/src/ipc-handlers/chat/mcp-tools.ts

@@ -0,0 +1,23 @@
+import { ipcMain } from 'electron'
+import { getMcpServerTools, getToolhiveMcpInfo } from '../../chat'
+import {
+  getEnabledMcpTools,
+  getEnabledMcpServersFromTools,
+  saveEnabledMcpTools,
+} from '../../chat/settings-storage'
+
+export function register() {
+  ipcMain.handle('chat:get-mcp-server-tools', (_, serverName: string) =>
+    getMcpServerTools(serverName)
+  )
+  ipcMain.handle('chat:get-enabled-mcp-tools', () => getEnabledMcpTools())
+  ipcMain.handle('chat:get-enabled-mcp-servers-from-tools', () =>
+    getEnabledMcpServersFromTools()
+  )
+  ipcMain.handle(
+    'chat:save-enabled-mcp-tools',
+    (_, serverName: string, enabledTools: string[]) =>
+      saveEnabledMcpTools(serverName, enabledTools)
+  )
+  ipcMain.handle('chat:get-toolhive-mcp-info', () => getToolhiveMcpInfo())
+}

main/src/ipc-handlers/chat/providers.ts

@@ -0,0 +1,18 @@
+import { ipcMain } from 'electron'
+import {
+  discoverToolSupportedModels,
+  fetchProviderModelsHandler,
+  getAllProvidersHandler,
+} from '../../chat/providers'
+
+export function register() {
+  ipcMain.handle(
+    'chat:fetch-provider-models',
+    (_, providerId: string, tempCredential?: string) =>
+      fetchProviderModelsHandler(providerId, tempCredential)
+  )
+
+  ipcMain.handle('chat:get-providers', () => getAllProvidersHandler())
+
+  ipcMain.handle('chat:discover-models', () => discoverToolSupportedModels())
+}

main/src/ipc-handlers/chat/settings.ts

@@ -0,0 +1,33 @@
+import { ipcMain } from 'electron'
+import {
+  getChatSettings,
+  clearChatSettings,
+  getSelectedModel,
+  saveSelectedModel,
+  handleSaveSettings,
+} from '../../chat/settings-storage'
+
+export function register() {
+  ipcMain.handle('chat:get-settings', (_, providerId: string) =>
+    getChatSettings(providerId as Parameters<typeof getChatSettings>[0])
+  )
+  ipcMain.handle(
+    'chat:save-settings',
+    (
+      _,
+      providerId: string,
+      settings:
+        | { apiKey: string; enabledTools: string[] }
+        | { endpointURL: string; enabledTools: string[] }
+    ) => handleSaveSettings(providerId, settings)
+  )
+  ipcMain.handle('chat:clear-settings', (_, providerId?: string) =>
+    clearChatSettings(providerId as Parameters<typeof clearChatSettings>[0])
+  )
+
+  ipcMain.handle('chat:get-selected-model', () => getSelectedModel())
+  ipcMain.handle(
+    'chat:save-selected-model',
+    (_, provider: string, model: string) => saveSelectedModel(provider, model)
+  )
+}

main/src/ipc-handlers/chat/streaming.ts

@@ -0,0 +1,10 @@
+import { ipcMain } from 'electron'
+import { type ChatRequest, handleChatStreamRealtime } from '../../chat'
+
+export function register() {
+  ipcMain.handle('chat:stream', async (event, request: ChatRequest) => {
+    const streamId = `stream-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`
+    handleChatStreamRealtime(request, streamId, event.sender)
+    return { streamId }
+  })
+}