feat: implement IPC handlers for registry and stacks management, including search, install, export, and import functionalities with corresponding unit tests

Author: Cyneric

TASK.md

@@ -62,11 +62,11 @@ affected unit tests pass, and both `pnpm build` and `pnpm lint` succeed.
 - [x] 39. Git sync: GitHub OAuth quick setup flow
 - [x] 40. Git sync: Advanced manual setup (any Git provider)
 - [x] 41. Push/pull with conflict detection and merge
-- [ ] 42. Smithery registry API client
-- [ ] 43. Registry browser page
-- [ ] 44. One-click install from registry (Pro feature)
-- [ ] 45. Import/export stacks (servers + rules bundles)
-- [ ] 46. MCP server connection testing (spawn, initialize, verify)
+- [x] 42. Smithery registry API client
+- [x] 43. Registry browser page
+- [x] 44. One-click install from registry (Pro feature)
+- [x] 45. Import/export stacks (servers + rules bundles)
+- [x] 46. MCP server connection testing (spawn, initialize, verify)
 
 ## Phase 6 — Polish + Release
 

eslint.config.js

@@ -121,6 +121,9 @@ export default [
     rules: {
       '@typescript-eslint/no-explicit-any': 'warn',
       '@typescript-eslint/no-non-null-assertion': 'off',
+      // Vitest patterns (vi.mocked, mock.calls, etc.) routinely access methods
+      // outside their original object context — this is intentional in tests.
+      '@typescript-eslint/unbound-method': 'off',
     },
   },
 ]

src/main/ipc/__tests__/registry.ipc.test.ts

@@ -0,0 +1,142 @@
+/**
+ * @file src/main/ipc/__tests__/registry.ipc.test.ts
+ *
+ * @created 07.03.2026
+ * @modified 07.03.2026
+ *
+ * @author Christian Blank <christianblank91@protonmail.com>
+ * @copyright 2026
+ *
+ * @description Unit tests for registry IPC handlers. The Smithery client,
+ * database repos, and feature gates are all mocked so tests run in isolation.
+ */
+
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+import { createTestDb } from '@main/db/__tests__/helpers'
+import { getDatabase } from '@main/db/connection'
+
+// ─── Module Mocks ─────────────────────────────────────────────────────────────
+
+vi.mock('electron', () => ({
+  ipcMain: { handle: vi.fn() },
+}))
+
+vi.mock('electron-log', () => ({
+  default: { debug: vi.fn(), info: vi.fn(), error: vi.fn(), warn: vi.fn() },
+}))
+
+vi.mock('@main/db/connection', () => ({ getDatabase: vi.fn() }))
+
+vi.mock('@main/licensing/feature-gates', () => ({
+  checkGate: vi.fn().mockImplementation((key: string) => {
+    if (key === 'registryInstall') return true
+    if (key === 'maxServers') return Infinity
+    return true
+  }),
+}))
+
+vi.mock('@main/registry/smithery.client', () => ({
+  smitheryClient: {
+    searchServers: vi.fn().mockResolvedValue([]),
+  },
+}))
+
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+
+import { ipcMain } from 'electron'
+import { checkGate } from '@main/licensing/feature-gates'
+import { smitheryClient } from '@main/registry/smithery.client'
+import { registerRegistryIpc } from '../registry.ipc'
+
+type IpcHandler = (_event: unknown, ...args: unknown[]) => unknown
+
+/** Returns the handler registered for a given channel. */
+const getHandler = (channel: string): IpcHandler => {
+  const calls = vi.mocked(ipcMain.handle).mock.calls
+  const call = calls.find(([ch]) => ch === channel)
+  if (!call) throw new Error(`No handler registered for "${channel}"`)
+  return call[1] as IpcHandler
+}
+
+// ─── Tests ────────────────────────────────────────────────────────────────────
+
+describe('registry IPC handlers', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    const db = createTestDb()
+    vi.mocked(getDatabase).mockReturnValue(db)
+    vi.mocked(checkGate).mockImplementation((key: string) => {
+      if (key === 'registryInstall') return true
+      if (key === 'maxServers') return Infinity
+      return true
+    })
+    registerRegistryIpc()
+  })
+
+  describe('registry:search', () => {
+    it('returns results from the Smithery client', async () => {
+      const mockResults = [
+        {
+          id: '@a/b',
+          displayName: 'B',
+          description: '',
+          source: 'smithery' as const,
+          verified: false,
+          remote: false,
+        },
+      ]
+      vi.mocked(smitheryClient.searchServers).mockResolvedValueOnce(mockResults)
+
+      const handler = getHandler('registry:search')
+      const result = await handler(null, 'github')
+
+      expect(smitheryClient.searchServers).toHaveBeenCalledWith('github')
+      expect(result).toEqual(mockResults)
+    })
+
+    it('returns empty array when Smithery returns nothing', async () => {
+      vi.mocked(smitheryClient.searchServers).mockResolvedValueOnce([])
+
+      const handler = getHandler('registry:search')
+      const result = await handler(null, 'nothing')
+
+      expect(result).toEqual([])
+    })
+  })
+
+  describe('registry:install', () => {
+    it('creates a server from the qualified name and returns it', async () => {
+      const handler = getHandler('registry:install')
+      const server = await handler(null, '@anthropic/github-mcp')
+
+      expect(server).toMatchObject({
+        name: 'github-mcp',
+        command: 'npx',
+        args: ['-y', '@anthropic/github-mcp'],
+        type: 'stdio',
+      })
+    })
+
+    it('throws when the registryInstall gate is false', async () => {
+      vi.mocked(checkGate).mockImplementation((key: string) => {
+        if (key === 'registryInstall') return false
+        if (key === 'maxServers') return Infinity
+        return true
+      })
+
+      const handler = getHandler('registry:install')
+      await expect(handler(null, '@some/server')).rejects.toThrow('Pro')
+    })
+
+    it('throws when the server limit is reached', async () => {
+      vi.mocked(checkGate).mockImplementation((key: string) => {
+        if (key === 'registryInstall') return true
+        if (key === 'maxServers') return 0
+        return true
+      })
+
+      const handler = getHandler('registry:install')
+      await expect(handler(null, '@some/server')).rejects.toThrow('limit')
+    })
+  })
+})

src/main/ipc/__tests__/stacks.ipc.test.ts

@@ -0,0 +1,169 @@
+/**
+ * @file src/main/ipc/__tests__/stacks.ipc.test.ts
+ *
+ * @created 07.03.2026
+ * @modified 07.03.2026
+ *
+ * @author Christian Blank <christianblank91@protonmail.com>
+ * @copyright 2026
+ *
+ * @description Unit tests for stacks IPC handlers. DB repos and feature gates
+ * are backed by an in-memory SQLite database so tests verify real persistence
+ * behavior without touching the filesystem.
+ */
+
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+import { createTestDb } from '@main/db/__tests__/helpers'
+import { getDatabase } from '@main/db/connection'
+import type { McpStack } from '@shared/channels'
+
+// ─── Module Mocks ─────────────────────────────────────────────────────────────
+
+vi.mock('electron', () => ({
+  ipcMain: { handle: vi.fn() },
+}))
+
+vi.mock('electron-log', () => ({
+  default: { debug: vi.fn(), info: vi.fn(), error: vi.fn(), warn: vi.fn() },
+}))
+
+vi.mock('@main/db/connection', () => ({ getDatabase: vi.fn() }))
+
+vi.mock('@main/licensing/feature-gates', () => ({
+  checkGate: vi.fn().mockImplementation((key: string) => {
+    if (key === 'stackExport') return true
+    return true
+  }),
+}))
+
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+
+import { ipcMain } from 'electron'
+import { checkGate } from '@main/licensing/feature-gates'
+import { registerStacksIpc } from '../stacks.ipc'
+
+type IpcHandler = (_event: unknown, ...args: unknown[]) => unknown
+
+const getHandler = (channel: string): IpcHandler => {
+  const calls = vi.mocked(ipcMain.handle).mock.calls
+  const call = calls.find(([ch]) => ch === channel)
+  if (!call) throw new Error(`No handler registered for "${channel}"`)
+  return call[1] as IpcHandler
+}
+
+const makeStack = (overrides: Partial<McpStack> = {}): string =>
+  JSON.stringify({
+    name: 'My Stack',
+    description: '',
+    version: '1.0.0',
+    servers: [
+      {
+        name: 'test-server',
+        type: 'stdio',
+        command: 'npx',
+        args: ['-y', '@test/mcp'],
+        env: {},
+        enabled: true,
+        tags: [],
+        notes: '',
+        createdAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+      },
+    ],
+    rules: [
+      {
+        name: 'test-rule',
+        description: '',
+        content: '# Test rule',
+        category: 'general',
+        tags: [],
+        enabled: true,
+        priority: 'normal',
+        scope: 'global',
+        fileGlobs: [],
+        alwaysApply: false,
+        tokenEstimate: 5,
+        createdAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+      },
+    ],
+    exportedAt: new Date().toISOString(),
+    ...overrides,
+  } satisfies McpStack)
+
+// ─── Tests ────────────────────────────────────────────────────────────────────
+
+describe('stacks IPC handlers', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    const db = createTestDb()
+    vi.mocked(getDatabase).mockReturnValue(db)
+    vi.mocked(checkGate).mockImplementation((key: string) => {
+      if (key === 'stackExport') return true
+      if (key === 'maxServers') return Infinity
+      return true
+    })
+    registerStacksIpc()
+  })
+
+  describe('stacks:export', () => {
+    it('returns a JSON string with the correct structure', async () => {
+      const handler = getHandler('stacks:export')
+      // No servers/rules seeded — exporting empty selection is valid.
+      const json = (await handler(null, [], [], 'Empty Stack')) as string
+
+      const stack = JSON.parse(json) as McpStack
+      expect(stack.name).toBe('Empty Stack')
+      expect(stack.version).toBe('1.0.0')
+      expect(stack.servers).toEqual([])
+      expect(stack.rules).toEqual([])
+      expect(typeof stack.exportedAt).toBe('string')
+    })
+
+    it('throws when the stackExport gate is false', async () => {
+      vi.mocked(checkGate).mockReturnValue(false)
+
+      const handler = getHandler('stacks:export')
+      await expect(handler(null, [], [], 'Stack')).rejects.toThrow('Pro')
+    })
+  })
+
+  describe('stacks:import', () => {
+    it('imports servers and rules from a valid stack JSON', async () => {
+      const handler = getHandler('stacks:import')
+      const result = (await handler(null, makeStack())) as {
+        imported: number
+        skipped: number
+        errors: string[]
+      }
+
+      expect(result.imported).toBe(2) // 1 server + 1 rule
+      expect(result.skipped).toBe(0)
+      expect(result.errors).toHaveLength(0)
+    })
+
+    it('skips duplicate server names on second import', async () => {
+      const handler = getHandler('stacks:import')
+      await handler(null, makeStack())
+      const result = (await handler(null, makeStack())) as { imported: number; skipped: number }
+
+      expect(result.skipped).toBe(2)
+      expect(result.imported).toBe(0)
+    })
+
+    it('returns an error for invalid JSON', async () => {
+      const handler = getHandler('stacks:import')
+      const result = (await handler(null, 'not-json')) as { imported: number; errors: string[] }
+
+      expect(result.imported).toBe(0)
+      expect(result.errors[0]).toMatch(/Invalid JSON/)
+    })
+
+    it('returns an error for JSON missing servers/rules arrays', async () => {
+      const handler = getHandler('stacks:import')
+      const result = (await handler(null, JSON.stringify({ name: 'bad' }))) as { errors: string[] }
+
+      expect(result.errors[0]).toMatch(/Invalid stack format/)
+    })
+  })
+})

src/main/ipc/index.ts

@@ -22,6 +22,8 @@ import { registerProfilesIpc } from './profiles.ipc'
 import { registerSecretsIpc } from './secrets.ipc'
 import { registerLicenseIpc } from './license.ipc'
 import { registerGitSyncIpc } from './git-sync.ipc'
+import { registerRegistryIpc } from './registry.ipc'
+import { registerStacksIpc } from './stacks.ipc'
 
 /**
  * Registers all IPC handlers for every implemented domain.
@@ -36,5 +38,7 @@ export const registerIpcHandlers = (): void => {
   registerProfilesIpc()
   registerLicenseIpc()
   registerGitSyncIpc()
+  registerRegistryIpc()
+  registerStacksIpc()
   log.info('[ipc] all handlers registered')
 }