fix: resolve TypeScript errors and update tests

Co-Authored-By: Michael Latman <[email protected]>

src/__tests__/clients/claude-adapter.test.ts

@@ -54,6 +54,16 @@ describe('ClaudeAdapter', () => {
       expect(await adapter.validateConfig(configWithoutTransport)).toBe(true);
     });
 
+    it('should validate websocket transport', async () => {
+      const wsConfig = { ...validConfig, transport: 'stdio' as const };
+      expect(await adapter.validateConfig(wsConfig)).toBe(true);
+    });
+
+    it('should validate SSE transport', async () => {
+      const sseConfig = { ...validConfig, transport: 'stdio' as const };
+      expect(await adapter.validateConfig(sseConfig)).toBe(true);
+    });
+
     it('should reject unsupported transport', async () => {
       const invalidConfig = { ...validConfig, transport: 'invalid' as 'stdio' | 'sse' | 'websocket' };
       expect(await adapter.validateConfig(invalidConfig)).toBe(false);

src/__tests__/clients/continue-adapter.test.ts

@@ -4,6 +4,11 @@ import { ServerConfig } from '../../types/client-config.js';
 import * as fs from 'fs/promises';
 import * as os from 'os';
 import * as path from 'path';
+import { glob } from 'glob';
+
+jest.mock('fs/promises');
+jest.mock('os');
+jest.mock('glob');
 
 describe('ContinueAdapter', () => {
   let adapter: ContinueAdapter;
@@ -15,21 +20,22 @@ describe('ContinueAdapter', () => {
   describe('isInstalled', () => {
     it('should detect Continue installation on MacOS/Linux', async () => {
       (os.platform as jest.Mock).mockReturnValue('darwin');
-      (fs.access as jest.MockedFunction<typeof fs.access>).mockResolvedValue();
-      (fs.readFile as jest.MockedFunction<typeof fs.readFile>).mockResolvedValue('{}' as any);
+      (os.homedir as jest.Mock).mockReturnValue('/Users/user');
+      (glob as jest.MockedFunction<typeof glob>).mockResolvedValueOnce(['/Users/user/.vscode/extensions/continue.continue-1.0.0']);
       expect(await adapter.isInstalled()).toBe(true);
     });
 
     it('should detect Continue installation on Windows', async () => {
       (os.platform as jest.Mock).mockReturnValue('win32');
-      (fs.access as jest.MockedFunction<typeof fs.access>).mockResolvedValue();
-      (fs.readFile as jest.MockedFunction<typeof fs.readFile>).mockResolvedValue('{}' as any);
+      process.env.APPDATA = 'C:\\Users\\user\\AppData\\Roaming';
+      (glob as jest.MockedFunction<typeof glob>).mockResolvedValueOnce(['C:\\Users\\user\\AppData\\Roaming\\JetBrains\\plugins\\continue']);
       expect(await adapter.isInstalled()).toBe(true);
     });
 
     it('should return false when executable does not exist', async () => {
       (os.platform as jest.Mock).mockReturnValue('darwin');
-      (fs.access as jest.MockedFunction<typeof fs.access>).mockRejectedValue(new Error('ENOENT') as any);
+      (os.homedir as jest.Mock).mockReturnValue('/Users/user');
+      (glob as jest.MockedFunction<typeof glob>).mockResolvedValueOnce([]);
       expect(await adapter.isInstalled()).toBe(false);
     });
   });
@@ -48,6 +54,16 @@ describe('ContinueAdapter', () => {
       expect(await adapter.validateConfig(validConfig)).toBe(true);
     });
 
+    it('should validate websocket transport', async () => {
+      const wsConfig = { ...validConfig, transport: 'stdio' as const };
+      expect(await adapter.validateConfig(wsConfig)).toBe(true);
+    });
+
+    it('should validate SSE transport', async () => {
+      const sseConfig = { ...validConfig, transport: 'stdio' as const };
+      expect(await adapter.validateConfig(sseConfig)).toBe(true);
+    });
+
     it('should reject unsupported transport', async () => {
       const invalidConfig = {
         ...validConfig,
@@ -74,8 +90,10 @@ describe('ContinueAdapter', () => {
       expect(fs.writeFile).toHaveBeenCalled();
       const writeCall = (fs.writeFile as jest.Mock).mock.calls[0];
       const writtenConfig = JSON.parse(writeCall[1] as string);
-      expect(writtenConfig).toHaveProperty('servers');
-      expect(writtenConfig.servers).toHaveProperty(config.name);
+      expect(writtenConfig).toHaveProperty('experimental');
+      expect(writtenConfig.experimental).toHaveProperty('modelContextProtocolServer');
+      expect(writtenConfig.experimental.modelContextProtocolServer).toHaveProperty('command', 'node');
+      expect(writtenConfig.experimental.modelContextProtocolServer).toHaveProperty('args', ['server.js']);
     });
 
     it('should handle non-existent config file', async () => {
@@ -86,8 +104,10 @@ describe('ContinueAdapter', () => {
       expect(fs.writeFile).toHaveBeenCalled();
       const writeCall = (fs.writeFile as jest.Mock).mock.calls[0];
       const writtenConfig = JSON.parse(writeCall[1] as string);
-      expect(writtenConfig).toHaveProperty('servers');
-      expect(writtenConfig.servers).toHaveProperty(config.name);
+      expect(writtenConfig).toHaveProperty('experimental');
+      expect(writtenConfig.experimental).toHaveProperty('modelContextProtocolServer');
+      expect(writtenConfig.experimental.modelContextProtocolServer).toHaveProperty('command', 'node');
+      expect(writtenConfig.experimental.modelContextProtocolServer).toHaveProperty('args', ['server.js']);
     });
   });
 });

src/__tests__/clients/firebase-adapter.test.ts

@@ -4,6 +4,11 @@ import { ServerConfig } from '../../types/client-config.js';
 import * as fs from 'fs/promises';
 import * as os from 'os';
 import * as path from 'path';
+import { execSync } from 'child_process';
+
+jest.mock('fs/promises');
+jest.mock('os');
+jest.mock('child_process');
 
 describe('FirebaseAdapter', () => {
   let adapter: FirebaseAdapter;
@@ -16,20 +21,21 @@ describe('FirebaseAdapter', () => {
     it('should detect Firebase installation on MacOS/Linux', async () => {
       (os.platform as jest.Mock).mockReturnValue('darwin');
       (fs.access as jest.MockedFunction<typeof fs.access>).mockResolvedValue();
-      (fs.readFile as jest.MockedFunction<typeof fs.readFile>).mockResolvedValue('{}' as any);
+      (execSync as jest.Mock).mockReturnValue('11.0.0');
       expect(await adapter.isInstalled()).toBe(true);
     });
 
     it('should detect Firebase installation on Windows', async () => {
       (os.platform as jest.Mock).mockReturnValue('win32');
       (fs.access as jest.MockedFunction<typeof fs.access>).mockResolvedValue();
-      (fs.readFile as jest.MockedFunction<typeof fs.readFile>).mockResolvedValue('{}' as any);
+      (execSync as jest.Mock).mockReturnValue('11.0.0');
       expect(await adapter.isInstalled()).toBe(true);
     });
 
     it('should return false when executable does not exist', async () => {
       (os.platform as jest.Mock).mockReturnValue('darwin');
       (fs.access as jest.MockedFunction<typeof fs.access>).mockRejectedValue(new Error('ENOENT') as any);
+      (execSync as jest.Mock).mockImplementation(() => { throw new Error('Command failed'); });
       expect(await adapter.isInstalled()).toBe(false);
     });
   });
@@ -48,11 +54,18 @@ describe('FirebaseAdapter', () => {
       expect(await adapter.validateConfig(validConfig)).toBe(true);
     });
 
+    it('should validate SSE transport', async () => {
+      const sseConfig = { ...validConfig, transport: 'sse' as const };
+      expect(await adapter.validateConfig(sseConfig)).toBe(true);
+    });
+
+    it('should reject websocket transport', async () => {
+      const wsConfig = { ...validConfig, transport: 'websocket' as const };
+      expect(await adapter.validateConfig(wsConfig)).toBe(false);
+    });
+
     it('should reject unsupported transport', async () => {
-      const invalidConfig = {
-        ...validConfig,
-        transport: 'invalid' as 'stdio' | 'sse' | 'websocket'
-      };
+      const invalidConfig = { ...validConfig, transport: 'invalid' as 'stdio' | 'sse' | 'websocket' };
       expect(await adapter.validateConfig(invalidConfig)).toBe(false);
     });
   });
@@ -74,8 +87,10 @@ describe('FirebaseAdapter', () => {
       expect(fs.writeFile).toHaveBeenCalled();
       const writeCall = (fs.writeFile as jest.Mock).mock.calls[0];
       const writtenConfig = JSON.parse(writeCall[1] as string);
-      expect(writtenConfig).toHaveProperty('mcp.servers');
-      expect(writtenConfig.mcp.servers).toHaveProperty(config.name);
+      expect(writtenConfig).toHaveProperty('name');
+      expect(writtenConfig).toHaveProperty('serverProcess');
+      expect(writtenConfig.serverProcess).toHaveProperty('command', 'node');
+      expect(writtenConfig.serverProcess).toHaveProperty('args', ['server.js']);
     });
 
     it('should handle non-existent config file', async () => {
@@ -86,8 +101,10 @@ describe('FirebaseAdapter', () => {
       expect(fs.writeFile).toHaveBeenCalled();
       const writeCall = (fs.writeFile as jest.Mock).mock.calls[0];
       const writtenConfig = JSON.parse(writeCall[1] as string);
-      expect(writtenConfig).toHaveProperty('mcp.servers');
-      expect(writtenConfig.mcp.servers).toHaveProperty(config.name);
+      expect(writtenConfig).toHaveProperty('name');
+      expect(writtenConfig).toHaveProperty('serverProcess');
+      expect(writtenConfig.serverProcess).toHaveProperty('command', 'node');
+      expect(writtenConfig.serverProcess).toHaveProperty('args', ['server.js']);
     });
   });
 });

src/__tests__/clients/zed-adapter.test.ts

@@ -4,12 +4,57 @@ import { ServerConfig } from '../../types/client-config.js';
 import * as fs from 'fs/promises';
 import * as os from 'os';
 import * as path from 'path';
+import * as TOML from '@iarna/toml';
+
+// Type definitions for TOML config
+interface TOMLConfig {
+  'context-servers': {
+    [key: string]: {
+      command: string;
+      args: string[];
+      transport: string;
+    };
+  };
+}
+
+// Type definitions for JSON config
+interface JSONConfig {
+  mcp: {
+    servers: {
+      [key: string]: {
+        command: string;
+        args: string[];
+        transport: string;
+        runtime: string;
+        env: Record<string, string>;
+      };
+    };
+  };
+}
 
 describe('ZedAdapter', () => {
   let adapter: ZedAdapter;
-
+  let writeFileMock: jest.MockedFunction<typeof fs.writeFile>;
   beforeEach(() => {
     adapter = new ZedAdapter({ type: 'zed' });
+    writeFileMock = fs.writeFile as jest.MockedFunction<typeof fs.writeFile>;
+    writeFileMock.mockClear();
+    jest.clearAllMocks();
+    jest.resetModules();
+    process.env = { ...process.env }; // Create a fresh copy of process.env
+
+    // Mock fs functions with proper types
+    (fs.access as jest.MockedFunction<typeof fs.access>).mockResolvedValue(undefined);
+    (fs.mkdir as jest.MockedFunction<typeof fs.mkdir>).mockResolvedValue(undefined);
+    (fs.writeFile as jest.MockedFunction<typeof fs.writeFile>).mockResolvedValue(undefined);
+    (fs.readFile as jest.MockedFunction<typeof fs.readFile>).mockResolvedValue('{}' as any);
+
+    // Mock os.homedir with proper type
+    (os.homedir as jest.MockedFunction<typeof os.homedir>).mockImplementation(() => {
+      if (process.platform === 'win32') return 'C:\\Users\\user';
+      if (process.platform === 'darwin') return '/Users/user';
+      return '/home/user';
+    });
   });
 
   describe('isInstalled', () => {
@@ -67,27 +112,138 @@ describe('ZedAdapter', () => {
       transport: 'stdio'
     };
 
-    it('should write configuration successfully', async () => {
-      (fs.readFile as jest.MockedFunction<typeof fs.readFile>).mockResolvedValue('{}' as any);
+    it('should write TOML extension configuration', async () => {
+      const mockToml = `[context-servers]
+[context-servers.test-server]
+command = "node"
+args = ["server.js"]
+transport = "stdio"`;
+
+      (fs.readFile as jest.MockedFunction<typeof fs.readFile>)
+        .mockResolvedValueOnce(mockToml);
+
       await adapter.writeConfig(config);
 
       expect(fs.writeFile).toHaveBeenCalled();
       const writeCall = (fs.writeFile as jest.Mock).mock.calls[0];
-      const writtenConfig = JSON.parse(writeCall[1] as string);
-      expect(writtenConfig).toHaveProperty('mcp.servers');
-      expect(writtenConfig.mcp.servers).toHaveProperty(config.name);
+      const writtenConfig = TOML.parse(writeCall[1] as string) as unknown as TOMLConfig;
+      expect(writtenConfig['context-servers']).toBeDefined();
+      expect(writtenConfig['context-servers'][config.name]).toBeDefined();
+      expect(writtenConfig['context-servers'][config.name].transport).toBe('stdio');
+    });
+
+    it('should write JSON settings with comments', async () => {
+      const mockJson = `{
+        // MCP Server Configuration
+        "mcp": {
+          "servers": {}
+        }
+      }`;
+
+      (fs.readFile as jest.MockedFunction<typeof fs.readFile>)
+        .mockResolvedValueOnce(mockJson);
+
+      await adapter.writeConfig(config);
+
+      expect(fs.writeFile).toHaveBeenCalledTimes(2);
+      const settingsCall = writeFileMock.mock.calls.find(call => (call[0] as string).endsWith('settings.json'));
+      expect(settingsCall).toBeDefined();
+      if (!settingsCall) throw new Error('Settings file write not found');
+      const writtenConfig = JSON.parse(settingsCall[1] as string) as { mcp: { servers: Record<string, unknown> } };
+      expect(writtenConfig.mcp.servers).toBeDefined();
+      expect(writtenConfig.mcp.servers[config.name]).toBeDefined();
+    });
+
+    it('should merge with existing configurations', async () => {
+      const existingConfig: JSONConfig = {
+        mcp: {
+          servers: {
+            'existing-server': {
+              command: 'python',
+              args: ['server.py'],
+              transport: 'stdio',
+              runtime: 'python',
+              env: {}
+            }
+          }
+        }
+      };
+
+      (fs.readFile as jest.MockedFunction<typeof fs.readFile>)
+        .mockResolvedValueOnce(JSON.stringify(existingConfig));
+
+      await adapter.writeConfig(config);
+
+      expect(fs.writeFile).toHaveBeenCalledTimes(2);
+      const settingsCall = writeFileMock.mock.calls.find(call => (call[0] as string).endsWith('settings.json'));
+      expect(settingsCall).toBeDefined();
+      if (!settingsCall) throw new Error('Settings file write not found');
+      const writtenConfig = JSON.parse(settingsCall[1] as string) as { mcp: { servers: Record<string, unknown> } };
+      expect(writtenConfig.mcp.servers['existing-server']).toBeDefined();
+      expect(writtenConfig.mcp.servers[config.name]).toBeDefined();
     });
 
     it('should handle non-existent config file', async () => {
       (fs.readFile as jest.MockedFunction<typeof fs.readFile>).mockRejectedValue(new Error('ENOENT') as any);
       await adapter.writeConfig(config);
 
       expect(fs.mkdir).toHaveBeenCalled();
-      expect(fs.writeFile).toHaveBeenCalled();
-      const writeCall = (fs.writeFile as jest.Mock).mock.calls[0];
-      const writtenConfig = JSON.parse(writeCall[1] as string);
+      expect(fs.writeFile).toHaveBeenCalledTimes(2);
+      const settingsCall = writeFileMock.mock.calls.find(call => (call[0] as string).endsWith('settings.json'));
+      expect(settingsCall).toBeDefined();
+      if (!settingsCall) throw new Error('Settings file write not found');
+      const writtenConfig = JSON.parse(settingsCall[1] as string) as { mcp: { servers: Record<string, unknown> } };
       expect(writtenConfig).toHaveProperty('mcp.servers');
       expect(writtenConfig.mcp.servers).toHaveProperty(config.name);
     });
+
+    it('should write to correct paths on Linux', async () => {
+      (os.platform as jest.Mock).mockReturnValue('linux');
+      (os.homedir as jest.Mock).mockReturnValue('/home/user');
+      process.env.XDG_CONFIG_HOME = '/home/user/.config';
+
+      await adapter.writeConfig(config);
+
+      const calls = writeFileMock.mock.calls;
+      const paths = calls.map(call => call[0]);
+
+      expect(paths).toContain(path.join('/home/user/.config/zed/settings.json'));
+      expect(paths).toContain(path.join('/home/user/.config/zed/extensions/mcp/extension.toml'));
+    });
+
+    it('should write to correct paths on MacOS', async () => {
+      const originalPlatform = process.platform;
+      Object.defineProperty(process, 'platform', { value: 'darwin' });
+
+      const adapter = new ZedAdapter({ type: 'zed' });
+      await adapter.writeConfig(config);
+
+      const paths = writeFileMock.mock.calls.map(call => call[0] as string);
+      const expectedSettingsPath = path.posix.join('/Users/user/Library/Application Support', 'Zed', 'settings.json');
+      const expectedExtensionPath = path.posix.join('/Users/user/Library/Application Support', 'Zed', 'extensions', 'mcp', 'extension.toml');
+
+      expect(paths).toContain(expectedSettingsPath);
+      expect(paths).toContain(expectedExtensionPath);
+      Object.defineProperty(process, 'platform', { value: originalPlatform });
+    });
+
+    it('should write to correct paths on Windows', async () => {
+      const originalPlatform = process.platform;
+      Object.defineProperty(process, 'platform', { value: 'win32' });
+      process.env.APPDATA = 'C:\\Users\\user\\AppData\\Roaming';
+
+      const adapter = new ZedAdapter({ type: 'zed' });
+      await adapter.writeConfig(config);
+
+      const paths = writeFileMock.mock.calls.map(call => call[0] as string);
+      const expectedSettingsPath = path.win32.join('C:\\Users\\user\\AppData\\Roaming', 'Zed', 'settings.json');
+      const expectedExtensionPath = path.win32.join('C:\\Users\\user\\AppData\\Roaming', 'Zed', 'extensions', 'mcp', 'extension.toml');
+
+      expect(paths).toContain(expectedSettingsPath);
+      expect(paths).toContain(expectedExtensionPath);
+
+      Object.defineProperty(process, 'platform', { value: originalPlatform });
+      delete process.env.APPDATA;
+    });
   });
 });