401 lines
18 KiB
TypeScript
401 lines
18 KiB
TypeScript
/**
|
|
* Persisted MCP config store + boot-time runtime population (Phase 4, C4).
|
|
*
|
|
* C4 was THE foundational Extend-layer gap: `McpRuntime` was instantiated
|
|
* empty at boot and nothing ever called addServer(), so "installed" MCPs were
|
|
* lost on restart and every /api/mcps route would have been dead. These tests
|
|
* cover the store CRUD and the exact populate function local/index.ts calls.
|
|
*/
|
|
|
|
import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
|
|
import fs from 'node:fs';
|
|
import * as path from 'node:path';
|
|
import * as os from 'node:os';
|
|
import { McpRuntime } from '@waggle/agent';
|
|
import { MCP_SERVERS, createMarketplaceMcpProvenance } from '@waggle/marketplace';
|
|
import {
|
|
loadMcpConfig,
|
|
saveMcpServerEntry,
|
|
removeMcpServerEntry,
|
|
validateMcpEntry,
|
|
mcpConfigPath,
|
|
populateMcpRuntimeFromConfig,
|
|
refreshMcpIfChanged,
|
|
_resetMcpSignatureCache,
|
|
type PersistedMcpEntry,
|
|
} from '../../src/local/mcp-config.js';
|
|
|
|
const canonicalSource = {
|
|
name: 'mcp_registry',
|
|
source_type: 'registry',
|
|
is_custom: false,
|
|
} as const;
|
|
|
|
function canonicalEntry(packageName: string, envValues: Record<string, string> = {}): PersistedMcpEntry {
|
|
const pkg = MCP_SERVERS.find((candidate) => candidate.name === packageName);
|
|
if (!pkg?.install_manifest?.mcp_config || !pkg.version) {
|
|
throw new Error(`Missing canonical MCP fixture: ${packageName}`);
|
|
}
|
|
const config = pkg.install_manifest.mcp_config;
|
|
const env = Object.fromEntries(
|
|
Object.keys(config.env ?? {}).map((key) => [key, envValues[key] ?? 'fixture-secret']),
|
|
);
|
|
return {
|
|
command: config.command,
|
|
args: [...config.args],
|
|
...(Object.keys(env).length > 0 ? { env } : {}),
|
|
provenance: createMarketplaceMcpProvenance(
|
|
canonicalSource,
|
|
{ name: pkg.name, version: pkg.version },
|
|
config,
|
|
),
|
|
};
|
|
}
|
|
|
|
describe('mcp-config store', () => {
|
|
let tmpDir: string;
|
|
|
|
beforeEach(() => {
|
|
tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'waggle-mcpcfg-'));
|
|
_resetMcpSignatureCache();
|
|
});
|
|
|
|
afterEach(() => {
|
|
vi.restoreAllMocks();
|
|
fs.rmSync(tmpDir, { recursive: true, force: true });
|
|
});
|
|
|
|
function configTempFiles(): string[] {
|
|
return fs.readdirSync(tmpDir).filter((name) => name.endsWith('.tmp'));
|
|
}
|
|
|
|
function filesystemError(code: string): NodeJS.ErrnoException {
|
|
return Object.assign(new Error(`filesystem error: ${code}`), { code });
|
|
}
|
|
|
|
it('returns an empty config when the file is missing', () => {
|
|
expect(loadMcpConfig(tmpDir)).toEqual({ mcpServers: {} });
|
|
});
|
|
|
|
it('returns an empty config on corrupt JSON (never throws) and quarantines the file', () => {
|
|
fs.writeFileSync(mcpConfigPath(tmpDir), '{ not json !!!', 'utf-8');
|
|
const warnings: string[] = [];
|
|
expect(loadMcpConfig(tmpDir, { warn: (m) => warnings.push(m) })).toEqual({ mcpServers: {} });
|
|
expect(warnings).toHaveLength(1);
|
|
expect(warnings[0]).toContain('quarantined');
|
|
// The corrupt original is preserved aside, never silently discarded
|
|
const quarantined = fs.readdirSync(tmpDir).filter((f) => f.includes('.corrupt-'));
|
|
expect(quarantined).toHaveLength(1);
|
|
expect(fs.existsSync(mcpConfigPath(tmpDir))).toBe(false);
|
|
});
|
|
|
|
it('a save after corruption cannot silently wipe the previous servers (quarantine keeps them)', () => {
|
|
saveMcpServerEntry(tmpDir, 'one', { command: 'node' });
|
|
saveMcpServerEntry(tmpDir, 'two', { command: 'uvx' });
|
|
// Crash-mid-write style truncation
|
|
fs.writeFileSync(mcpConfigPath(tmpDir), '{ "mcpServers": { "one": { "comm', 'utf-8');
|
|
|
|
// First touch (read-modify-write save) quarantines, then starts fresh
|
|
const silent = { warn: () => { /* quiet */ } };
|
|
expect(loadMcpConfig(tmpDir, silent)).toEqual({ mcpServers: {} });
|
|
saveMcpServerEntry(tmpDir, 'three', { command: 'bun' });
|
|
|
|
expect(Object.keys(loadMcpConfig(tmpDir).mcpServers)).toEqual(['three']);
|
|
// The pre-corruption data is still on disk for manual recovery
|
|
const quarantined = fs.readdirSync(tmpDir).filter((f) => f.includes('.corrupt-'));
|
|
expect(quarantined).toHaveLength(1);
|
|
expect(fs.readFileSync(path.join(tmpDir, quarantined[0]), 'utf-8')).toContain('mcpServers');
|
|
});
|
|
|
|
it('quarantines a structurally invalid config before a later save can overwrite it', () => {
|
|
const invalidConfig = JSON.stringify({ mcpServers: [], recoveryMarker: 'keep-me' });
|
|
fs.writeFileSync(mcpConfigPath(tmpDir), invalidConfig, 'utf-8');
|
|
|
|
expect(loadMcpConfig(tmpDir, { warn: () => { /* quiet */ } })).toEqual({ mcpServers: {} });
|
|
saveMcpServerEntry(tmpDir, 'replacement', { command: 'node' });
|
|
|
|
expect(loadMcpConfig(tmpDir).mcpServers.replacement).toEqual({ command: 'node' });
|
|
const quarantined = fs.readdirSync(tmpDir).filter((name) => name.includes('.corrupt-'));
|
|
expect(quarantined).toHaveLength(1);
|
|
expect(fs.readFileSync(path.join(tmpDir, quarantined[0]), 'utf-8')).toBe(invalidConfig);
|
|
});
|
|
|
|
it('save/remove round-trips entries (installer-compatible shape)', () => {
|
|
saveMcpServerEntry(tmpDir, 'custom-filesystem', { command: 'npx', args: ['@modelcontextprotocol/server-filesystem', '/tmp'] });
|
|
saveMcpServerEntry(tmpDir, 'custom-db', { command: 'node', args: ['db.js'], env: { DB_URL: 'sqlite://x' }, workspaceId: 'ws-1' });
|
|
|
|
const cfg = loadMcpConfig(tmpDir);
|
|
expect(Object.keys(cfg.mcpServers).sort()).toEqual(['custom-db', 'custom-filesystem']);
|
|
expect(cfg.mcpServers['custom-db'].workspaceId).toBe('ws-1');
|
|
|
|
// Upsert replaces, not duplicates
|
|
saveMcpServerEntry(tmpDir, 'custom-filesystem', { command: 'node', args: ['fs.js'] });
|
|
const cfg2 = loadMcpConfig(tmpDir);
|
|
expect(Object.keys(cfg2.mcpServers)).toHaveLength(2);
|
|
expect(cfg2.mcpServers['custom-filesystem'].command).toBe('node');
|
|
|
|
expect(removeMcpServerEntry(tmpDir, 'custom-filesystem')).toBe(true);
|
|
expect(removeMcpServerEntry(tmpDir, 'custom-filesystem')).toBe(false);
|
|
expect(Object.keys(loadMcpConfig(tmpDir).mcpServers)).toEqual(['custom-db']);
|
|
});
|
|
|
|
it.each(['EPERM', 'EACCES', 'EBUSY'] as const)(
|
|
'retries a transient Windows %s rename lock without losing the config update',
|
|
(code) => {
|
|
const renameSync = fs.renameSync.bind(fs);
|
|
const rename = vi.spyOn(fs, 'renameSync')
|
|
.mockImplementationOnce(() => { throw filesystemError(code); })
|
|
.mockImplementation(renameSync);
|
|
const wait = vi.spyOn(Atomics, 'wait').mockReturnValue('timed-out');
|
|
|
|
saveMcpServerEntry(tmpDir, 'custom-safe', { command: 'node', args: ['safe.js'] });
|
|
|
|
expect(rename).toHaveBeenCalledTimes(2);
|
|
expect(wait).toHaveBeenCalledOnce();
|
|
expect(loadMcpConfig(tmpDir).mcpServers['custom-safe']).toEqual({
|
|
command: 'node',
|
|
args: ['safe.js'],
|
|
});
|
|
expect(configTempFiles()).toEqual([]);
|
|
},
|
|
);
|
|
|
|
it('bounds a persistent Windows rename lock and preserves the prior config', () => {
|
|
saveMcpServerEntry(tmpDir, 'custom-safe', { command: 'node', args: ['v1.js'] });
|
|
const error = filesystemError('EPERM');
|
|
const rename = vi.spyOn(fs, 'renameSync').mockImplementation(() => { throw error; });
|
|
const wait = vi.spyOn(Atomics, 'wait').mockReturnValue('timed-out');
|
|
|
|
expect(() => saveMcpServerEntry(
|
|
tmpDir,
|
|
'custom-safe',
|
|
{ command: 'node', args: ['v2.js'] },
|
|
)).toThrow(error);
|
|
|
|
expect(rename).toHaveBeenCalledTimes(4);
|
|
expect(wait).toHaveBeenCalledTimes(3);
|
|
expect(loadMcpConfig(tmpDir).mcpServers['custom-safe']).toEqual({
|
|
command: 'node',
|
|
args: ['v1.js'],
|
|
});
|
|
expect(configTempFiles()).toEqual([]);
|
|
});
|
|
|
|
it('round-trips a canonical marketplace provenance receipt without exposing env values', () => {
|
|
const entry = canonicalEntry('brave-search', { BRAVE_API_KEY: 'sentinel-secret' });
|
|
saveMcpServerEntry(tmpDir, 'brave-search', entry);
|
|
|
|
const persisted = loadMcpConfig(tmpDir).mcpServers['brave-search'];
|
|
expect(persisted).toEqual(entry);
|
|
expect(JSON.stringify(persisted.provenance)).not.toContain('sentinel-secret');
|
|
});
|
|
|
|
it('upgrades an exact legacy marketplace profile without losing configured secrets', () => {
|
|
const legacy = canonicalEntry('brave-search', { BRAVE_API_KEY: 'legacy-secret' });
|
|
delete legacy.provenance;
|
|
fs.writeFileSync(mcpConfigPath(tmpDir), JSON.stringify({ mcpServers: {
|
|
'brave-search': legacy,
|
|
'custom-safe': { command: 'node', args: ['safe.js'] },
|
|
} }), 'utf-8');
|
|
|
|
const loaded = loadMcpConfig(tmpDir);
|
|
expect(loaded.mcpServers['brave-search'].provenance).toMatchObject({
|
|
kind: 'marketplace',
|
|
packageName: 'brave-search',
|
|
});
|
|
expect(loaded.mcpServers['brave-search'].env).toEqual({ BRAVE_API_KEY: 'legacy-secret' });
|
|
expect(loaded.mcpServers['custom-safe']).toEqual({ command: 'node', args: ['safe.js'] });
|
|
expect(fs.readdirSync(tmpDir).some((name) => name.startsWith('.mcp.json.quarantine-'))).toBe(false);
|
|
expect(JSON.parse(fs.readFileSync(mcpConfigPath(tmpDir), 'utf-8'))
|
|
.mcpServers['brave-search'].provenance.packageName).toBe('brave-search');
|
|
});
|
|
|
|
it('quarantines provenance downgrade and profile tampering while preserving custom MCPs', () => {
|
|
const tampered = canonicalEntry('brave-search', { BRAVE_API_KEY: 'sentinel-quarantine-secret' });
|
|
tampered.command = 'powershell.exe';
|
|
fs.writeFileSync(mcpConfigPath(tmpDir), JSON.stringify({
|
|
mcpServers: {
|
|
memory: {
|
|
command: 'powershell.exe',
|
|
args: ['--yes', '--ignore-scripts', '@modelcontextprotocol/server-memory@2026.7.4'],
|
|
},
|
|
'brave-search': tampered,
|
|
'custom-safe': { command: 'node', args: ['safe.js'] },
|
|
},
|
|
}), 'utf-8');
|
|
const warnings: string[] = [];
|
|
|
|
expect(loadMcpConfig(tmpDir, { warn: (message) => warnings.push(message) })).toEqual({
|
|
mcpServers: {
|
|
'custom-safe': { command: 'node', args: ['safe.js'] },
|
|
},
|
|
});
|
|
expect(warnings.join('\n')).toMatch(/provenance|approved marketplace profile/i);
|
|
|
|
const quarantineName = fs.readdirSync(tmpDir).find((name) => name.startsWith('.mcp.json.quarantine-'));
|
|
expect(quarantineName).toBeDefined();
|
|
const quarantine = JSON.parse(fs.readFileSync(path.join(tmpDir, quarantineName!), 'utf-8'));
|
|
expect(quarantine.entries.memory.reason).toMatch(/provenance/i);
|
|
expect(quarantine.entries['brave-search'].reason).toMatch(/profile|command/i);
|
|
expect(quarantine.entries['brave-search'].entry.env).toEqual({
|
|
BRAVE_API_KEY: 'sentinel-quarantine-secret',
|
|
});
|
|
const active = fs.readFileSync(mcpConfigPath(tmpDir), 'utf-8');
|
|
expect(active).not.toContain('sentinel-quarantine-secret');
|
|
expect(Object.keys(JSON.parse(active).mcpServers)).toEqual(['custom-safe']);
|
|
});
|
|
|
|
it('validateMcpEntry rejects bad names and shapes', () => {
|
|
expect(validateMcpEntry('ok-name_1.2', { command: 'node' })).toBeNull();
|
|
expect(validateMcpEntry('', { command: 'node' })).toMatch(/invalid server name/);
|
|
expect(validateMcpEntry('../escape', { command: 'node' })).toMatch(/invalid server name/);
|
|
expect(validateMcpEntry('has space', { command: 'node' })).toMatch(/invalid server name/);
|
|
expect(validateMcpEntry('x', { command: '' })).toMatch(/command/);
|
|
expect(validateMcpEntry('x', { command: 'node', args: 'nope' })).toMatch(/args/);
|
|
expect(validateMcpEntry('x', { command: 'node', env: { A: 1 } })).toMatch(/env/);
|
|
expect(validateMcpEntry('x', { command: 'node', workspaceId: 7 })).toMatch(/workspaceId/);
|
|
expect(validateMcpEntry('x', null)).toMatch(/object/);
|
|
});
|
|
|
|
it('requires and verifies provenance for reserved marketplace server names', () => {
|
|
const memory = canonicalEntry('memory');
|
|
expect(validateMcpEntry('memory', memory)).toBeNull();
|
|
expect(validateMcpEntry('memory', { command: memory.command, args: memory.args })).toMatch(/provenance/i);
|
|
expect(validateMcpEntry('memory', {
|
|
...memory,
|
|
provenance: { ...memory.provenance!, profileDigest: `sha256:${'0'.repeat(64)}` },
|
|
})).toMatch(/digest|provenance/i);
|
|
expect(validateMcpEntry('custom-memory', { command: 'node', args: ['memory.js'] })).toBeNull();
|
|
expect(validateMcpEntry('postgres', { command: 'node', args: ['custom.js'] })).toMatch(/catalog|reserved/i);
|
|
|
|
const secretA = canonicalEntry('brave-search', { BRAVE_API_KEY: 'secret-a' });
|
|
const secretB = canonicalEntry('brave-search', { BRAVE_API_KEY: 'secret-b' });
|
|
expect(secretA.provenance).toEqual(secretB.provenance);
|
|
expect(validateMcpEntry('brave-search', secretA)).toBeNull();
|
|
expect(validateMcpEntry('brave-search', secretB)).toBeNull();
|
|
|
|
const variants: PersistedMcpEntry[] = [
|
|
{ ...secretA, args: [...secretA.args!, '--drift'] },
|
|
{ ...secretA, env: { ...secretA.env, NODE_OPTIONS: '--require=evil.js' } },
|
|
{ ...secretA, provenance: { ...secretA.provenance!, packageVersion: '999.0.0' } },
|
|
{ ...secretA, provenance: { ...secretA.provenance!, npmPackage: '@scope/other@1.0.0' } },
|
|
];
|
|
for (const variant of variants) expect(validateMcpEntry('brave-search', variant)).not.toBeNull();
|
|
});
|
|
|
|
it('uses ~/.waggle when dataDir is empty (same fallback as index.ts)', () => {
|
|
expect(mcpConfigPath('')).toBe(path.join(os.homedir(), '.waggle', '.mcp.json'));
|
|
});
|
|
});
|
|
|
|
describe('populateMcpRuntimeFromConfig (C4 boot population)', () => {
|
|
let tmpDir: string;
|
|
|
|
beforeEach(() => {
|
|
tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'waggle-mcpboot-'));
|
|
_resetMcpSignatureCache();
|
|
});
|
|
|
|
afterEach(() => {
|
|
fs.rmSync(tmpDir, { recursive: true, force: true });
|
|
});
|
|
|
|
it('registers valid entries WITHOUT starting them; skips bad ones; never throws', () => {
|
|
fs.writeFileSync(mcpConfigPath(tmpDir), JSON.stringify({
|
|
mcpServers: {
|
|
'good-one': { command: 'node', args: ['a.js'] },
|
|
'good-two': { command: 'uvx', args: ['srv'], workspaceId: 'ws-9' },
|
|
'no-command': { args: ['broken.js'] },
|
|
'bad name!': { command: 'node' },
|
|
},
|
|
}), 'utf-8');
|
|
|
|
const runtime = new McpRuntime();
|
|
const result = populateMcpRuntimeFromConfig(runtime, tmpDir);
|
|
|
|
expect(result.registered.sort()).toEqual(['good-one', 'good-two']);
|
|
expect(result.skipped.map((s) => s.name).sort()).toEqual(['bad name!', 'no-command']);
|
|
|
|
const states = runtime.getServerStates();
|
|
expect(Object.keys(states).sort()).toEqual(['good-one', 'good-two']);
|
|
// Register-only: nothing spawned at boot
|
|
expect(states['good-one']).toBe('stopped');
|
|
expect(states['good-two']).toBe('stopped');
|
|
// Per-entry workspace scoping survives the round-trip (C19)
|
|
expect(runtime.getServer('good-two')!.config.workspaceId).toBe('ws-9');
|
|
});
|
|
|
|
it('is safe to call against an already-populated runtime (duplicates skip, not throw)', () => {
|
|
fs.writeFileSync(mcpConfigPath(tmpDir), JSON.stringify({
|
|
mcpServers: { dup: { command: 'node' } },
|
|
}), 'utf-8');
|
|
|
|
const runtime = new McpRuntime();
|
|
expect(populateMcpRuntimeFromConfig(runtime, tmpDir).registered).toEqual(['dup']);
|
|
const second = populateMcpRuntimeFromConfig(runtime, tmpDir);
|
|
expect(second.registered).toEqual([]);
|
|
expect(second.skipped[0].reason).toMatch(/already registered/);
|
|
expect(Object.keys(runtime.getServerStates())).toEqual(['dup']);
|
|
});
|
|
|
|
it('handles a missing config file (empty runtime, no throw)', () => {
|
|
const runtime = new McpRuntime();
|
|
const result = populateMcpRuntimeFromConfig(runtime, tmpDir);
|
|
expect(result.registered).toEqual([]);
|
|
expect(Object.keys(runtime.getServerStates())).toEqual([]);
|
|
});
|
|
|
|
it('hot reload preserves running configuration when mcpServers has an array shape', async () => {
|
|
const original = { mcpServers: { 'custom-safe': { command: 'node', args: ['safe.js'] } } };
|
|
fs.writeFileSync(mcpConfigPath(tmpDir), JSON.stringify(original), 'utf-8');
|
|
const runtime = new McpRuntime();
|
|
expect(populateMcpRuntimeFromConfig(runtime, tmpDir).registered).toEqual(['custom-safe']);
|
|
|
|
const invalidConfig = JSON.stringify({ mcpServers: [], recoveryMarker: 'keep-me' });
|
|
fs.writeFileSync(mcpConfigPath(tmpDir), invalidConfig, 'utf-8');
|
|
const result = await refreshMcpIfChanged(runtime, tmpDir);
|
|
|
|
expect(result.error).toMatch(/mcpServers/i);
|
|
expect(result.removed).toEqual([]);
|
|
expect(runtime.getServer('custom-safe')).toBeDefined();
|
|
expect(fs.readFileSync(mcpConfigPath(tmpDir), 'utf-8')).toBe(invalidConfig);
|
|
});
|
|
|
|
it('registers verified marketplace entries at boot and removes them when hot-reload detects tampering', async () => {
|
|
const memory = canonicalEntry('memory');
|
|
const custom = { command: 'node', args: ['safe.js'] };
|
|
fs.writeFileSync(mcpConfigPath(tmpDir), JSON.stringify({
|
|
mcpServers: { memory, 'custom-safe': custom },
|
|
}), 'utf-8');
|
|
const runtime = new McpRuntime();
|
|
|
|
expect(populateMcpRuntimeFromConfig(runtime, tmpDir).registered.sort()).toEqual(['custom-safe', 'memory']);
|
|
expect(runtime.getServer('memory')).toBeDefined();
|
|
|
|
fs.writeFileSync(mcpConfigPath(tmpDir), JSON.stringify({
|
|
mcpServers: {
|
|
memory: {
|
|
...memory,
|
|
provenance: { ...memory.provenance!, profileDigest: `sha256:${'f'.repeat(64)}` },
|
|
},
|
|
'custom-safe': custom,
|
|
},
|
|
}), 'utf-8');
|
|
const result = await refreshMcpIfChanged(runtime, tmpDir);
|
|
|
|
expect(result.removed).toEqual(['memory']);
|
|
expect(result.skipped[0]).toMatchObject({ name: 'memory' });
|
|
expect(result.skipped[0].reason).toMatch(/digest|provenance/i);
|
|
expect(runtime.getServer('memory')).toBeUndefined();
|
|
expect(runtime.getServer('custom-safe')).toBeDefined();
|
|
expect(fs.readdirSync(tmpDir).some((name) => name.startsWith('.mcp.json.quarantine-'))).toBe(true);
|
|
|
|
const quarantineCount = fs.readdirSync(tmpDir)
|
|
.filter((name) => name.startsWith('.mcp.json.quarantine-')).length;
|
|
const second = await refreshMcpIfChanged(runtime, tmpDir);
|
|
expect(second).toMatchObject({ changed: false, added: [], removed: [], reregistered: [], skipped: [] });
|
|
expect(fs.readdirSync(tmpDir)
|
|
.filter((name) => name.startsWith('.mcp.json.quarantine-'))).toHaveLength(quarantineCount);
|
|
});
|
|
});
|