feat: add client management page and enhance server configuration with URL support for SSE and HTTP transport types

Author: Cyneric

resources/icon.ico

@@ -8,9 +8,7 @@
  * @copyright 2026
  *
  * @description Central registry of all client adapters. IPC handlers and
- * services look up adapters here rather than importing them directly. The map
- * is populated with the three Phase 1 adapters; Phase 2 (Step 18) adds the
- * remaining five (Windsurf, Claude Code, Zed, JetBrains, Codex CLI).
+ * services look up adapters here rather than importing them directly.
  */
 
 import type { ClientId } from '@shared/types'

resources/tray-icon.png

@@ -14,7 +14,7 @@
  */
 
 import Database from 'better-sqlite3'
-import { MIGRATION_001 } from '../migrations/index'
+import { MIGRATION_001, MIGRATION_002 } from '../migrations/index'
 
 /**
  * Creates a fresh in-memory SQLite database with the full schema applied.
@@ -29,5 +29,6 @@ export const createTestDb = (): Database.Database => {
   const db = new Database(':memory:')
   db.pragma('foreign_keys = ON')
   db.exec(MIGRATION_001)
+  db.exec(MIGRATION_002)
   return db
 }

src/main/clients/registry.ts

@@ -17,10 +17,10 @@ import { join } from 'path'
 import Database from 'better-sqlite3'
 import { app } from 'electron'
 import log from 'electron-log'
-import { MIGRATION_001 } from './migrations/index'
+import { MIGRATION_001, MIGRATION_002 } from './migrations/index'
 
 /** All migration scripts in order. Index = version - 1. */
-const MIGRATIONS: readonly string[] = [MIGRATION_001]
+const MIGRATIONS: readonly string[] = [MIGRATION_001, MIGRATION_002]
 
 /** Lazily-created singleton instance. */
 let instance: Database.Database | null = null

src/main/db/__tests__/helpers.ts

@@ -10,6 +10,10 @@
  * @description Exports all SQLite migration scripts as typed string constants.
  * Keeping them here avoids file-path resolution issues across dev, test, and
  * packaged Electron builds — no readFileSync or path gymnastics needed.
+ *
+ * Migration history:
+ *   001 — Initial schema (servers, rules, profiles, backups, activity_log, settings)
+ *   002 — Add `url` column to servers (for SSE and HTTP transport types)
  */
 
 /**
@@ -102,3 +106,12 @@ CREATE INDEX idx_activity_log_timestamp ON activity_log(timestamp);
 CREATE INDEX idx_activity_log_action ON activity_log(action);
 CREATE INDEX idx_backups_client ON backups(client_id);
 `
+
+/**
+ * Migration 002 — Adds the `url` column to the `servers` table.
+ * Required for SSE and HTTP transport types where the server is reached via
+ * a network endpoint rather than a spawned process.
+ */
+export const MIGRATION_002 = /* sql */ `
+ALTER TABLE servers ADD COLUMN url TEXT NOT NULL DEFAULT '';
+`

src/main/db/connection.ts

@@ -27,6 +27,7 @@ interface ServerRow {
   id: string
   name: string
   type: string
+  url: string
   command: string
   args: string
   env: string
@@ -51,6 +52,7 @@ const rowToServer = (row: ServerRow): McpServer => ({
   id: row.id,
   name: row.name,
   type: row.type as McpServer['type'],
+  ...(row.url ? { url: row.url } : {}),
   command: row.command,
   args: JSON.parse(row.args) as string[],
   env: JSON.parse(row.env) as Record<string, string>,
@@ -109,15 +111,16 @@ export class ServersRepo {
     this.db
       .prepare(
         `INSERT INTO servers
-          (id, name, type, command, args, env, secret_env_keys, enabled,
+          (id, name, type, url, command, args, env, secret_env_keys, enabled,
            client_overrides, tags, notes, created_at, updated_at)
          VALUES
-          (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+          (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
       )
       .run(
         id,
         input.name,
         input.type,
+        input.url ?? '',
         input.command,
         JSON.stringify(input.args ?? []),
         JSON.stringify(input.env ?? {}),
@@ -157,14 +160,15 @@ export class ServersRepo {
     this.db
       .prepare(
         `UPDATE servers SET
-          name = ?, type = ?, command = ?, args = ?, env = ?,
+          name = ?, type = ?, url = ?, command = ?, args = ?, env = ?,
           secret_env_keys = ?, enabled = ?, client_overrides = ?,
           tags = ?, notes = ?, updated_at = ?
          WHERE id = ?`,
       )
       .run(
         updates.name ?? existing.name,
         updates.type ?? existing.type,
+        updates.url ?? existing.url ?? '',
         updates.command ?? existing.command,
         JSON.stringify(updates.args ?? existing.args),
         JSON.stringify(updates.env ?? existing.env),

src/main/db/migrations/index.ts

@@ -14,7 +14,13 @@
 
 import { ipcMain } from 'electron'
 import log from 'electron-log'
-import type { ClientId, ClientStatus, McpServerMap, SyncResult } from '@shared/types'
+import type {
+  ClientId,
+  ClientStatus,
+  McpServerMap,
+  SyncResult,
+  ValidationResult,
+} from '@shared/types'
 import { ADAPTERS, ADAPTER_IDS } from '@main/clients/registry'
 import { getDatabase } from '@main/db/connection'
 import { ServersRepo } from '@main/db/servers.repo'
@@ -147,5 +153,28 @@ export const registerClientsIpc = (): void => {
     return results
   })
 
+  // ── clients:validate-config ───────────────────────────────────────────────
+  ipcMain.handle(
+    'clients:validate-config',
+    async (_event, clientId: ClientId): Promise<ValidationResult> => {
+      log.debug(`[ipc] clients:validate-config ${clientId}`)
+
+      const adapter = ADAPTERS.get(clientId)
+      if (!adapter) {
+        return { valid: false, errors: [`Unknown client: ${clientId}`] }
+      }
+
+      const detection = await adapter.detect()
+      if (!detection.installed || detection.configPaths.length === 0) {
+        return {
+          valid: false,
+          errors: [`${adapter.displayName} is not installed or has no config file`],
+        }
+      }
+
+      return adapter.validate(detection.configPaths[0]!)
+    },
+  )
+
   log.info('[ipc] clients handlers registered')
 }

src/main/db/servers.repo.ts

@@ -10,20 +10,23 @@
  * @description LemonSqueezy license validation service. Handles activation,
  * validation, and deactivation of license keys via the LemonSqueezy API.
  *
- * The validation result is cached in `electron.safeStorage` (encrypted AES-256
- * on Windows) so the app can start instantly without a network round-trip. The
- * cache is considered stale after 7 days and re-validated in the background.
- * If the network is unavailable during re-validation, a 7-day grace period
- * keeps the cached status active. On expiry or an explicit invalid response
- * the app falls back to the free tier.
+ * The validation result is encrypted via `electron.safeStorage` (AES-256 on
+ * Windows) and persisted to `<userData>/license.enc` so the app can start
+ * instantly without a network round-trip on every launch. The cache is
+ * considered stale after 7 days and re-validated in the background. If the
+ * network is unavailable during re-validation, a 7-day grace period keeps the
+ * cached status active. On expiry or an explicit invalid response the app
+ * falls back to the free tier.
  *
  * Lifecycle:
- *   app start → getStatus() reads cache → background re-validate if stale
- *   user enters key → activateLicense(key) → validate → update cache
- *   user deactivates → deactivateLicense() → API call → clear cache
+ *   app start → getStatus() reads cache file → background re-validate if stale
+ *   user enters key → activateLicense(key) → validate → update cache file
+ *   user deactivates → deactivateLicense() → API call → delete cache file
  */
 
-import { safeStorage } from 'electron'
+import { safeStorage, app } from 'electron'
+import { existsSync, readFileSync, writeFileSync, unlinkSync } from 'fs'
+import { join } from 'path'
 import log from 'electron-log'
 import type { LicenseStatus, PlanTier } from '@shared/types'
 
@@ -47,8 +50,11 @@ const CACHE_TTL_MS = 7 * 24 * 60 * 60 * 1000
  */
 const GRACE_PERIOD_MS = 7 * 24 * 60 * 60 * 1000
 
-/** safeStorage encryption key name used to persist the license cache. */
-const STORAGE_KEY = 'aidrelay-license-cache'
+/**
+ * Returns the absolute path to the encrypted license cache file.
+ * Stored in the per-user Electron userData directory so it survives app restarts.
+ */
+const cachePath = (): string => join(app.getPath('userData'), 'license.enc')
 
 // ─── Internal Cache Shape ─────────────────────────────────────────────────────
 
@@ -76,44 +82,53 @@ const freeTierStatus = (): LicenseStatus => ({
 })
 
 /**
- * Reads and decrypts the cached license data from `electron.safeStorage`.
- * Returns `null` if nothing is stored or decryption fails.
+ * Reads and decrypts the cached license data from the encrypted file on disk.
+ * Returns `null` if the file does not exist, encryption is unavailable, or
+ * the file contents cannot be decrypted (e.g. the OS key changed).
  */
 const readCache = (): LicenseCache | null => {
   try {
     if (!safeStorage.isEncryptionAvailable()) return null
-    const stored = process.env['_AIDRELAY_LICENSE_CACHE']
-    if (!stored) return null
-    const decrypted = safeStorage.decryptString(Buffer.from(stored, 'base64'))
+    const file = cachePath()
+    if (!existsSync(file)) return null
+    const encrypted = readFileSync(file)
+    const decrypted = safeStorage.decryptString(encrypted)
     return JSON.parse(decrypted) as LicenseCache
   } catch {
     return null
   }
 }
 
 /**
- * Encrypts and writes license cache data to `electron.safeStorage`.
+ * Encrypts the license cache and writes it to `<userData>/license.enc`.
+ * The file is replaced atomically so a partial write never corrupts it.
+ *
+ * @param cache - The cache data to persist.
  */
 const writeCache = (cache: LicenseCache): void => {
   try {
     if (!safeStorage.isEncryptionAvailable()) return
     const json = JSON.stringify(cache)
     const encrypted = safeStorage.encryptString(json)
-    // Store in memory env var as a stand-in for a real persistent key-value store.
-    // In production this would be written to app.getPath('userData')/license.enc
-    process.env['_AIDRELAY_LICENSE_CACHE'] = encrypted.toString('base64')
+    writeFileSync(cachePath(), encrypted)
     log.debug(`[license] cache written for key ending ...${cache.key.slice(-4)}`)
   } catch (err) {
     log.warn('[license] failed to write cache:', err)
   }
 }
 
 /**
- * Clears the cached license data from `electron.safeStorage`.
+ * Deletes the encrypted license cache file from disk.
+ * Safe to call even if the file does not exist.
  */
 const clearCache = (): void => {
-  delete process.env['_AIDRELAY_LICENSE_CACHE']
-  log.debug('[license] cache cleared')
+  try {
+    const file = cachePath()
+    if (existsSync(file)) unlinkSync(file)
+    log.debug('[license] cache cleared')
+  } catch (err) {
+    log.warn('[license] failed to clear cache:', err)
+  }
 }
 
 // ─── API Calls ────────────────────────────────────────────────────────────────
@@ -294,7 +309,6 @@ export const deactivateLicense = async (): Promise<void> => {
     await apiDeactivate(cache.key)
   }
   clearCache()
-  // Suppress unused variable warning for STORE_ID in stub implementation.
-  void STORAGE_KEY
+  // STORE_ID is used via environment variable — suppress the unused warning.
   void STORE_ID
 }

src/main/ipc/clients.ipc.ts

@@ -24,7 +24,9 @@
  * checks from non-published builds.
  */
 
-import { autoUpdater } from 'electron-updater'
+import updaterPkg from 'electron-updater'
+
+const { autoUpdater } = updaterPkg
 import { BrowserWindow } from 'electron'
 import log from 'electron-log'
 import { is } from '@electron-toolkit/utils'