456 lines
15 KiB
TypeScript
456 lines
15 KiB
TypeScript
import { describe, it, expect, vi, beforeEach } from 'vitest';
|
|
import { PassThrough } from 'stream';
|
|
import { McpServerInstance, McpRuntime, type McpServerConfig, type McpProcess, type SpawnFn } from '../src/mcp/mcp-runtime.js';
|
|
|
|
/** Minimal JSON-RPC request shape the mock server reads off the wire. */
|
|
interface MockJsonRpcRequest {
|
|
id?: number | string | null;
|
|
method?: string;
|
|
params?: { name?: string; arguments?: { path?: string } };
|
|
}
|
|
|
|
// ── Mock MCP Process Factory ───────────────────────────────────────────
|
|
|
|
function createMockMcpProcess() {
|
|
const stdin = new PassThrough();
|
|
const stdout = new PassThrough();
|
|
const stderr = new PassThrough();
|
|
|
|
const mockProcess: McpProcess = {
|
|
stdin,
|
|
stdout,
|
|
stderr,
|
|
pid: 12345,
|
|
kill: vi.fn(() => true),
|
|
on: vi.fn((event: string, listener: (...args: unknown[]) => void) => {
|
|
// Store exit/error handlers for manual triggering
|
|
(mockProcess as unknown as Record<string, unknown>)[`_${event}Handler`] = listener;
|
|
return mockProcess;
|
|
}),
|
|
removeAllListeners: vi.fn(() => mockProcess),
|
|
};
|
|
|
|
// Auto-respond to JSON-RPC requests
|
|
const toolList = [
|
|
{
|
|
name: 'read_file',
|
|
description: 'Read a file from disk',
|
|
inputSchema: { type: 'object', properties: { path: { type: 'string' } }, required: ['path'] },
|
|
},
|
|
{
|
|
name: 'list_files',
|
|
description: 'List files in a directory',
|
|
inputSchema: { type: 'object', properties: { dir: { type: 'string' } } },
|
|
},
|
|
];
|
|
|
|
stdin.on('data', (chunk: Buffer) => {
|
|
const line = chunk.toString().trim();
|
|
if (!line) return;
|
|
|
|
let request: MockJsonRpcRequest;
|
|
try {
|
|
request = JSON.parse(line);
|
|
} catch {
|
|
return;
|
|
}
|
|
|
|
// Skip notifications (no id)
|
|
if (request.id == null) return;
|
|
|
|
let result: unknown;
|
|
switch (request.method) {
|
|
case 'initialize':
|
|
result = { protocolVersion: '2024-11-05', capabilities: {}, serverInfo: { name: 'mock-server' } };
|
|
break;
|
|
case 'tools/list':
|
|
result = { tools: toolList };
|
|
break;
|
|
case 'tools/call':
|
|
if (request.params?.name === 'read_file') {
|
|
result = { content: [{ type: 'text', text: `Contents of ${request.params.arguments?.path ?? 'unknown'}` }] };
|
|
} else {
|
|
result = { content: [{ type: 'text', text: 'ok' }] };
|
|
}
|
|
break;
|
|
default:
|
|
result = {};
|
|
}
|
|
|
|
const response = JSON.stringify({ jsonrpc: '2.0', id: request.id, result }) + '\n';
|
|
// Respond async to simulate real I/O
|
|
setImmediate(() => stdout.write(response));
|
|
});
|
|
|
|
return { mockProcess, stdin, stdout, stderr, toolList };
|
|
}
|
|
|
|
function createMockSpawn(): { spawn: SpawnFn; lastProcess: () => ReturnType<typeof createMockMcpProcess> } {
|
|
let last: ReturnType<typeof createMockMcpProcess> | null = null;
|
|
const spawn: SpawnFn = () => {
|
|
last = createMockMcpProcess();
|
|
return last.mockProcess;
|
|
};
|
|
return { spawn, lastProcess: () => last! };
|
|
}
|
|
|
|
const baseConfig: McpServerConfig = {
|
|
name: 'test-server',
|
|
command: 'node',
|
|
args: ['mock-mcp.js'],
|
|
};
|
|
|
|
// ── McpServerInstance Tests ────────────────────────────────────────────
|
|
|
|
describe('McpServerInstance', () => {
|
|
it('starts and reaches ready state', async () => {
|
|
const { spawn } = createMockSpawn();
|
|
const instance = new McpServerInstance(baseConfig, { spawn });
|
|
|
|
expect(instance.getState()).toBe('stopped');
|
|
await instance.start();
|
|
expect(instance.getState()).toBe('ready');
|
|
await instance.stop();
|
|
});
|
|
|
|
it('discovers tools from server', async () => {
|
|
const { spawn } = createMockSpawn();
|
|
const instance = new McpServerInstance(baseConfig, { spawn });
|
|
|
|
await instance.start();
|
|
const tools = instance.getTools();
|
|
expect(tools).toHaveLength(2);
|
|
expect(tools[0].name).toBe('read_file');
|
|
expect(tools[1].name).toBe('list_files');
|
|
await instance.stop();
|
|
});
|
|
|
|
it('forwards tool calls and returns results', async () => {
|
|
const { spawn } = createMockSpawn();
|
|
const instance = new McpServerInstance(baseConfig, { spawn });
|
|
|
|
await instance.start();
|
|
const result = await instance.callTool('read_file', { path: '/tmp/test.txt' });
|
|
expect(result).toEqual({
|
|
content: [{ type: 'text', text: 'Contents of /tmp/test.txt' }],
|
|
});
|
|
await instance.stop();
|
|
});
|
|
|
|
it('handles server crash (state → error)', async () => {
|
|
const { spawn, lastProcess } = createMockSpawn();
|
|
const instance = new McpServerInstance(baseConfig, { spawn });
|
|
|
|
await instance.start();
|
|
expect(instance.getState()).toBe('ready');
|
|
|
|
// Simulate process exit
|
|
const exitHandler = (lastProcess().mockProcess as unknown as Record<string, () => void>)._exitHandler;
|
|
expect(exitHandler).toBeDefined();
|
|
exitHandler();
|
|
|
|
expect(instance.getState()).toBe('error');
|
|
});
|
|
|
|
it('handles tool call timeout', async () => {
|
|
// Create a process that never responds to tools/call
|
|
const stdin = new PassThrough();
|
|
const stdout = new PassThrough();
|
|
const stderr = new PassThrough();
|
|
const silentProcess: McpProcess = {
|
|
stdin, stdout, stderr, pid: 99,
|
|
kill: vi.fn(() => true),
|
|
on: vi.fn(() => silentProcess),
|
|
removeAllListeners: vi.fn(() => silentProcess),
|
|
};
|
|
|
|
// Respond to initialize and tools/list, but NOT tools/call
|
|
stdin.on('data', (chunk: Buffer) => {
|
|
const line = chunk.toString().trim();
|
|
if (!line) return;
|
|
let request: MockJsonRpcRequest;
|
|
try { request = JSON.parse(line); } catch { return; }
|
|
if (request.id == null) return;
|
|
|
|
if (request.method === 'initialize' || request.method === 'tools/list') {
|
|
const result = request.method === 'initialize'
|
|
? { protocolVersion: '2024-11-05', capabilities: {}, serverInfo: { name: 'slow' } }
|
|
: { tools: [{ name: 'slow_tool', description: 'Slow', inputSchema: {} }] };
|
|
setImmediate(() => stdout.write(JSON.stringify({ jsonrpc: '2.0', id: request.id, result }) + '\n'));
|
|
}
|
|
// tools/call → no response (triggers timeout)
|
|
});
|
|
|
|
const spawnFn: SpawnFn = () => silentProcess;
|
|
const instance = new McpServerInstance(baseConfig, { spawn: spawnFn, toolCallTimeoutMs: 100 });
|
|
|
|
await instance.start();
|
|
await expect(instance.callTool('slow_tool', {})).rejects.toThrow(/Timeout/);
|
|
await instance.stop();
|
|
});
|
|
|
|
it('stop terminates process', async () => {
|
|
const { spawn, lastProcess } = createMockSpawn();
|
|
const instance = new McpServerInstance(baseConfig, { spawn });
|
|
|
|
await instance.start();
|
|
await instance.stop();
|
|
|
|
expect(lastProcess().mockProcess.kill).toHaveBeenCalled();
|
|
expect(instance.getState()).toBe('stopped');
|
|
expect(instance.getTools()).toHaveLength(0);
|
|
});
|
|
|
|
it('emits state change events', async () => {
|
|
const { spawn } = createMockSpawn();
|
|
const instance = new McpServerInstance(baseConfig, { spawn });
|
|
const events: Array<{ from: string; to: string }> = [];
|
|
|
|
instance.on('stateChange', (e: { from: string; to: string }) => {
|
|
events.push({ from: e.from, to: e.to });
|
|
});
|
|
|
|
await instance.start();
|
|
await instance.stop();
|
|
|
|
expect(events).toEqual([
|
|
{ from: 'stopped', to: 'starting' },
|
|
{ from: 'starting', to: 'ready' },
|
|
{ from: 'ready', to: 'stopped' },
|
|
]);
|
|
});
|
|
|
|
it('rejects callTool when not ready', async () => {
|
|
const { spawn } = createMockSpawn();
|
|
const instance = new McpServerInstance(baseConfig, { spawn });
|
|
|
|
await expect(instance.callTool('read_file', {})).rejects.toThrow(/not ready/);
|
|
});
|
|
|
|
it('isHealthy returns true only when ready', async () => {
|
|
const { spawn } = createMockSpawn();
|
|
const instance = new McpServerInstance(baseConfig, { spawn });
|
|
|
|
expect(instance.isHealthy()).toBe(false);
|
|
await instance.start();
|
|
expect(instance.isHealthy()).toBe(true);
|
|
await instance.stop();
|
|
expect(instance.isHealthy()).toBe(false);
|
|
});
|
|
});
|
|
|
|
// ── McpRuntime Tests ───────────────────────────────────────────────────
|
|
|
|
describe('McpRuntime', () => {
|
|
let runtime: McpRuntime;
|
|
let spawnFn: SpawnFn;
|
|
|
|
beforeEach(() => {
|
|
const mock = createMockSpawn();
|
|
spawnFn = mock.spawn;
|
|
runtime = new McpRuntime({ spawn: spawnFn });
|
|
});
|
|
|
|
it('registers multiple servers', () => {
|
|
runtime.addServer({ name: 'server-a', command: 'node', args: ['a.js'] });
|
|
runtime.addServer({ name: 'server-b', command: 'node', args: ['b.js'] });
|
|
|
|
expect(runtime.getServer('server-a')).toBeDefined();
|
|
expect(runtime.getServer('server-b')).toBeDefined();
|
|
expect(runtime.getServer('server-c')).toBeUndefined();
|
|
});
|
|
|
|
it('throws on duplicate server name', () => {
|
|
runtime.addServer({ name: 'dup', command: 'node' });
|
|
expect(() => runtime.addServer({ name: 'dup', command: 'node' })).toThrow(/already registered/);
|
|
});
|
|
|
|
it('startAll() starts all servers', async () => {
|
|
runtime.addServer({ name: 's1', command: 'node' });
|
|
runtime.addServer({ name: 's2', command: 'node' });
|
|
|
|
await runtime.startAll();
|
|
|
|
const states = runtime.getServerStates();
|
|
expect(states['s1']).toBe('ready');
|
|
expect(states['s2']).toBe('ready');
|
|
|
|
await runtime.stopAll();
|
|
});
|
|
|
|
it('stopAll() stops all servers', async () => {
|
|
runtime.addServer({ name: 's1', command: 'node' });
|
|
runtime.addServer({ name: 's2', command: 'node' });
|
|
|
|
await runtime.startAll();
|
|
await runtime.stopAll();
|
|
|
|
const states = runtime.getServerStates();
|
|
expect(states['s1']).toBe('stopped');
|
|
expect(states['s2']).toBe('stopped');
|
|
});
|
|
|
|
it('getAllTools() aggregates from ready servers only', async () => {
|
|
runtime.addServer({ name: 'ready-server', command: 'node' });
|
|
runtime.addServer({ name: 'stopped-server', command: 'node' });
|
|
|
|
// Only start the first server
|
|
await runtime.getServer('ready-server')!.start();
|
|
|
|
const tools = runtime.getAllTools();
|
|
// ready-server has 2 tools, stopped-server has 0
|
|
expect(tools).toHaveLength(2);
|
|
expect(tools.every(t => t.name.startsWith('mcp_ready-server_'))).toBe(true);
|
|
|
|
await runtime.stopAll();
|
|
});
|
|
|
|
it('getToolsForWorkspace() filters by workspace', async () => {
|
|
runtime.addServer({ name: 'global', command: 'node' });
|
|
runtime.addServer({ name: 'ws1-only', command: 'node', workspaceId: 'ws1' });
|
|
runtime.addServer({ name: 'ws2-only', command: 'node', workspaceId: 'ws2' });
|
|
|
|
await runtime.startAll();
|
|
|
|
const ws1Tools = runtime.getToolsForWorkspace('ws1');
|
|
const ws1Names = ws1Tools.map(t => t.name);
|
|
// Should include global + ws1-only, not ws2-only
|
|
expect(ws1Names.some(n => n.startsWith('mcp_global_'))).toBe(true);
|
|
expect(ws1Names.some(n => n.startsWith('mcp_ws1-only_'))).toBe(true);
|
|
expect(ws1Names.some(n => n.startsWith('mcp_ws2-only_'))).toBe(false);
|
|
|
|
const ws2Tools = runtime.getToolsForWorkspace('ws2');
|
|
expect(ws2Tools.some(t => t.name.startsWith('mcp_ws2-only_'))).toBe(true);
|
|
expect(ws2Tools.some(t => t.name.startsWith('mcp_ws1-only_'))).toBe(false);
|
|
|
|
await runtime.stopAll();
|
|
});
|
|
|
|
it('getServerStates() returns all states', async () => {
|
|
runtime.addServer({ name: 'a', command: 'node' });
|
|
runtime.addServer({ name: 'b', command: 'node' });
|
|
|
|
const states = runtime.getServerStates();
|
|
expect(states).toEqual({ a: 'stopped', b: 'stopped' });
|
|
});
|
|
|
|
it('tool names are prefixed with server name', async () => {
|
|
runtime.addServer({ name: 'github', command: 'node' });
|
|
await runtime.startAll();
|
|
|
|
const tools = runtime.getAllTools();
|
|
expect(tools[0].name).toBe('mcp_github_read_file');
|
|
expect(tools[1].name).toBe('mcp_github_list_files');
|
|
|
|
await runtime.stopAll();
|
|
});
|
|
|
|
it('tool execute forwards call to server and returns string', async () => {
|
|
runtime.addServer({ name: 'fs', command: 'node' });
|
|
await runtime.startAll();
|
|
|
|
const tools = runtime.getAllTools();
|
|
const readFileTool = tools.find(t => t.name === 'mcp_fs_read_file')!;
|
|
expect(readFileTool).toBeDefined();
|
|
|
|
const result = await readFileTool.execute({ path: '/etc/hosts' });
|
|
// Result is JSON-stringified because callTool returns an object
|
|
expect(result).toContain('Contents of /etc/hosts');
|
|
|
|
await runtime.stopAll();
|
|
});
|
|
|
|
it('getHealthy() returns only ready servers', async () => {
|
|
runtime.addServer({ name: 'up', command: 'node' });
|
|
runtime.addServer({ name: 'down', command: 'node' });
|
|
|
|
await runtime.getServer('up')!.start();
|
|
|
|
const healthy = runtime.getHealthy();
|
|
expect(healthy).toHaveLength(1);
|
|
expect(healthy[0].config.name).toBe('up');
|
|
|
|
await runtime.stopAll();
|
|
});
|
|
|
|
it('removeServer() stops and removes a server', async () => {
|
|
runtime.addServer({ name: 'removable', command: 'node' });
|
|
await runtime.startAll();
|
|
|
|
expect(runtime.getServer('removable')).toBeDefined();
|
|
await runtime.removeServer('removable');
|
|
expect(runtime.getServer('removable')).toBeUndefined();
|
|
expect(runtime.getServerStates()).toEqual({});
|
|
});
|
|
|
|
it('emits serverStateChange events', async () => {
|
|
const events: Array<{ server: string; to: string }> = [];
|
|
runtime.on('serverStateChange', (e: { server: string; to: string }) => {
|
|
events.push({ server: e.server, to: e.to });
|
|
});
|
|
|
|
runtime.addServer({ name: 'ev', command: 'node' });
|
|
await runtime.startAll();
|
|
await runtime.stopAll();
|
|
|
|
expect(events.map(e => e.to)).toEqual(['starting', 'ready', 'stopped']);
|
|
expect(events.every(e => e.server === 'ev')).toBe(true);
|
|
});
|
|
|
|
it('isServerHealthy checks actual health', async () => {
|
|
runtime.addServer({ name: 'h', command: 'node' });
|
|
|
|
expect(runtime.isServerHealthy('h')).toBe(false);
|
|
expect(runtime.isServerHealthy('nonexistent')).toBe(false);
|
|
|
|
await runtime.startAll();
|
|
expect(runtime.isServerHealthy('h')).toBe(true);
|
|
|
|
await runtime.stopAll();
|
|
});
|
|
});
|
|
|
|
// ── Capability Router + McpRuntime integration ─────────────────────────
|
|
|
|
describe('CapabilityRouter MCP health-awareness', () => {
|
|
it('marks MCP route as unavailable when runtime reports unhealthy', async () => {
|
|
// Import inline to avoid circular issues in test
|
|
const { CapabilityRouter } = await import('../src/capability-router.js');
|
|
|
|
const mockRuntime = { isServerHealthy: (name: string) => name === 'healthy-mcp' };
|
|
|
|
const router = new CapabilityRouter({
|
|
toolNames: [],
|
|
skills: [],
|
|
plugins: [],
|
|
mcpServers: ['healthy-mcp', 'unhealthy-mcp'],
|
|
subAgentRoles: [],
|
|
mcpRuntime: mockRuntime,
|
|
});
|
|
|
|
const routes = router.resolve('mcp');
|
|
const healthyRoute = routes.find(r => r.name === 'healthy-mcp');
|
|
const unhealthyRoute = routes.find(r => r.name === 'unhealthy-mcp');
|
|
|
|
expect(healthyRoute?.available).toBe(true);
|
|
expect(unhealthyRoute?.available).toBe(false);
|
|
expect(unhealthyRoute?.description).toContain('not healthy');
|
|
});
|
|
|
|
it('assumes available when no mcpRuntime is provided (backward compat)', async () => {
|
|
const { CapabilityRouter } = await import('../src/capability-router.js');
|
|
|
|
const router = new CapabilityRouter({
|
|
toolNames: [],
|
|
skills: [],
|
|
plugins: [],
|
|
mcpServers: ['some-mcp'],
|
|
subAgentRoles: [],
|
|
// no mcpRuntime
|
|
});
|
|
|
|
const routes = router.resolve('some');
|
|
expect(routes[0]).toMatchObject({ source: 'mcp', available: true });
|
|
});
|
|
});
|