@wener/mcps 1.0.1

package/src/server/config.test.ts

@@ -0,0 +1,162 @@
+import { describe, it, expect, afterEach, beforeEach } from 'vitest';
+import { loadConfig } from './config';
+import { writeFileSync, existsSync, mkdirSync, rmSync } from 'node:fs';
+import { resolve, join } from 'node:path';
+import YAML from 'yaml';
+import { tmpdir } from 'node:os';
+
+describe('Config Loading', () => {
+	// Use a unique temp directory for each test to avoid conflicts
+	let testDir: string;
+
+	beforeEach(() => {
+		testDir = join(tmpdir(), `mcps-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+		mkdirSync(testDir, { recursive: true });
+	});
+
+	afterEach(() => {
+		// Cleanup test directory
+		if (existsSync(testDir)) {
+			rmSync(testDir, { recursive: true, force: true });
+		}
+	});
+
+	describe('YAML config loading', () => {
+		it('should load YAML config from .mcps.yaml', () => {
+			const config = {
+				servers: {
+					'test-relay': {
+						type: 'relay',
+						url: 'https://example.com/mcp',
+					},
+				},
+				models: [
+					{
+						name: 'test-model',
+						baseUrl: 'http://localhost:8080',
+						adapter: 'openai',
+					},
+				],
+			};
+
+			// Write YAML config
+			writeFileSync(resolve(testDir, '.mcps.yaml'), YAML.stringify(config));
+
+			const loaded = loadConfig(testDir);
+			expect(loaded.servers['test-relay']).toBeDefined();
+			expect(loaded.servers['test-relay'].type).toBe('relay');
+			expect(loaded.models).toHaveLength(1);
+			expect(loaded.models?.[0].name).toBe('test-model');
+			expect(loaded.models?.[0].baseUrl).toBe('http://localhost:8080');
+		});
+
+		it('should prefer YAML over JSON when both exist', () => {
+			// Write JSON config (lower priority)
+			writeFileSync(
+				resolve(testDir, '.mcps.json'),
+				JSON.stringify({
+					servers: {
+						'json-server': { type: 'prometheus', url: 'http://json.example.com' },
+					},
+				}),
+			);
+
+			// Write YAML config (higher priority)
+			writeFileSync(
+				resolve(testDir, '.mcps.yaml'),
+				YAML.stringify({
+					servers: {
+						'yaml-server': { type: 'relay', url: 'https://yaml.example.com' },
+					},
+				}),
+			);
+
+			const loaded = loadConfig(testDir);
+			// Both servers should be present since configs are merged
+			expect(loaded.servers['yaml-server']).toBeDefined();
+			expect(loaded.servers['json-server']).toBeDefined();
+		});
+
+		it('should merge local config over base config', () => {
+			// Write base config
+			writeFileSync(
+				resolve(testDir, '.mcps.yaml'),
+				YAML.stringify({
+					servers: {
+						'base-server': { type: 'relay', url: 'https://base.example.com' },
+					},
+					models: [
+						{
+							name: 'base-model',
+							baseUrl: 'http://base:8080',
+							adapter: 'openai',
+						},
+					],
+				}),
+			);
+
+			// Write local config (higher priority)
+			writeFileSync(
+				resolve(testDir, '.mcps.local.yaml'),
+				YAML.stringify({
+					servers: {
+						'local-server': { type: 'prometheus', url: 'http://local.example.com' },
+					},
+					models: [
+						{
+							name: 'local-model',
+							baseUrl: 'http://local:8080',
+							adapter: 'anthropic',
+						},
+					],
+				}),
+			);
+
+			const loaded = loadConfig(testDir);
+			// Both servers should be present
+			expect(loaded.servers['base-server']).toBeDefined();
+			expect(loaded.servers['local-server']).toBeDefined();
+			// Both models should be present
+			expect(loaded.models).toHaveLength(2);
+			expect(loaded.models?.find((m) => m.name === 'base-model')).toBeDefined();
+			expect(loaded.models?.find((m) => m.name === 'local-model')).toBeDefined();
+		});
+
+		it('should override model by name in local config', () => {
+			// Write base config
+			writeFileSync(
+				resolve(testDir, '.mcps.yaml'),
+				YAML.stringify({
+					models: [
+						{
+							name: 'shared-model',
+							baseUrl: 'http://base:8080',
+							adapter: 'openai',
+						},
+					],
+				}),
+			);
+
+			// Write local config with same model name (should override)
+			writeFileSync(
+				resolve(testDir, '.mcps.local.yaml'),
+				YAML.stringify({
+					models: [
+						{
+							name: 'shared-model',
+							baseUrl: 'http://local:9090',
+							adapter: 'anthropic',
+						},
+					],
+				}),
+			);
+
+			const loaded = loadConfig(testDir);
+			// Only one model with the name
+			expect(loaded.models).toHaveLength(1);
+			expect(loaded.models?.[0].name).toBe('shared-model');
+			expect(loaded.models?.[0].baseUrl).toBe('http://local:9090');
+			expect(loaded.models?.[0].adapter).toBe('anthropic');
+		});
+	});
+});

package/src/server/config.ts

@@ -0,0 +1,198 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import consola from 'consola';
+import YAML from 'yaml';
+import { McpsConfigSchema, type McpsConfig, type ServerConfig } from './schema';
+
+const log = consola.withTag('config');
+
+/**
+ * Load .env files into process.env
+ * Priority: .env.local > .env (later files override earlier)
+ */
+export function loadEnvFiles(cwd: string = process.cwd()): void {
+	const envFiles = ['.env', '.env.local'];
+
+	for (const envFile of envFiles) {
+		const filePath = resolve(cwd, envFile);
+		if (!existsSync(filePath)) continue;
+
+		try {
+			const content = readFileSync(filePath, 'utf-8');
+			const lines = content.split('\n');
+
+			for (const line of lines) {
+				const trimmed = line.trim();
+				// Skip empty lines and comments
+				if (!trimmed || trimmed.startsWith('#')) continue;
+
+				const eqIndex = trimmed.indexOf('=');
+				if (eqIndex === -1) continue;
+
+				const key = trimmed.slice(0, eqIndex).trim();
+				let value = trimmed.slice(eqIndex + 1).trim();
+
+				// Remove quotes if present
+				if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"))) {
+					value = value.slice(1, -1);
+				}
+
+				// Only set if not already set (don't override existing env vars)
+				if (process.env[key] === undefined) {
+					process.env[key] = value;
+					log.debug(`Loaded env var ${key} from ${envFile}`);
+				}
+			}
+			log.info(`Loaded env file: ${envFile}`);
+		} catch (e) {
+			log.warn(`Failed to load ${envFile}:`, e);
+		}
+	}
+}
+
+/**
+ * Parse config file content based on format
+ */
+function parseConfigContent(content: string, format: 'yaml' | 'json'): unknown {
+	if (format === 'yaml') {
+		return YAML.parse(content);
+	}
+	return JSON.parse(content);
+}
+
+/**
+ * Load and parse a single config file
+ */
+function loadConfigFile(filePath: string, format: 'yaml' | 'json'): { data: McpsConfig; path: string } | null {
+	if (!existsSync(filePath)) {
+		return null;
+	}
+
+	try {
+		const content = readFileSync(filePath, 'utf-8');
+		const parsed = parseConfigContent(content, format);
+		const result = McpsConfigSchema.safeParse(parsed);
+
+		if (result.success) {
+			log.info(`Loaded config from ${filePath}`);
+			return { data: result.data, path: filePath };
+		} else {
+			log.warn(`Invalid config in ${filePath}: ${result.error.message}`);
+			return null;
+		}
+	} catch (e) {
+		log.error(`Failed to load ${filePath}:`, e);
+		return null;
+	}
+}
+
+/**
+ * Load config from multiple config files with priority merging
+ *
+ * Priority (highest to lowest):
+ * 1. .mcps.local.yaml/.yml/.json (local overrides for mcps)
+ * 2. .mcps.yaml/.yml/.json (base mcps config)
+ * 3. .mcp.local.yaml/.yml/.json (local overrides for mcp)
+ * 4. .mcp.yaml/.yml/.json (base mcp config)
+ *
+ * Within each group, YAML has higher priority than JSON.
+ * All found configs are merged, with higher priority configs overriding lower ones.
+ */
+export function loadConfig(cwd: string = process.cwd()): McpsConfig {
+	const config: McpsConfig = { servers: {} };
+
+	// Load configs in reverse priority order (lowest first, so higher priority overwrites)
+	// We want: base configs first, then local configs
+	// And within each: json first, then yaml (yaml overwrites json)
+	const loadOrder = [
+		// Base MCP configs (lowest priority)
+		{ path: '.mcp.json', format: 'json' as const },
+		{ path: '.mcp.yml', format: 'yaml' as const },
+		{ path: '.mcp.yaml', format: 'yaml' as const },
+		// Local MCP configs
+		{ path: '.mcp.local.json', format: 'json' as const },
+		{ path: '.mcp.local.yml', format: 'yaml' as const },
+		{ path: '.mcp.local.yaml', format: 'yaml' as const },
+		// Base MCPS configs
+		{ path: '.mcps.json', format: 'json' as const },
+		{ path: '.mcps.yml', format: 'yaml' as const },
+		{ path: '.mcps.yaml', format: 'yaml' as const },
+		// Local MCPS configs (highest priority)
+		{ path: '.mcps.local.json', format: 'json' as const },
+		{ path: '.mcps.local.yml', format: 'yaml' as const },
+		{ path: '.mcps.local.yaml', format: 'yaml' as const },
+	];
+
+	for (const { path: configPath, format } of loadOrder) {
+		const fullPath = resolve(cwd, configPath);
+		const result = loadConfigFile(fullPath, format);
+		if (result) {
+			// Merge servers, later configs take precedence
+			Object.assign(config.servers, result.data.servers);
+
+			// Merge models config (array format - later configs append/override by name)
+			if (result.data.models && result.data.models.length > 0) {
+				if (!config.models) {
+					config.models = [];
+				}
+				// Merge by name - later config overrides earlier ones with same name
+				for (const model of result.data.models) {
+					const existingIndex = config.models.findIndex((m) => m.name === model.name);
+					if (existingIndex >= 0) {
+						config.models[existingIndex] = model;
+					} else {
+						config.models.push(model);
+					}
+				}
+			}
+		}
+	}
+
+	// Filter disabled servers
+	for (const [name, serverConfig] of Object.entries(config.servers)) {
+		if (serverConfig.disabled) {
+			log.debug(`Server ${name} is disabled`);
+			delete config.servers[name];
+		}
+	}
+
+	return config;
+}
+
+/**
+ * Substitute environment variables in config values
+ * Supports ${VAR_NAME} syntax
+ */
+export function substituteEnvVars(config: McpsConfig): McpsConfig {
+	const result: McpsConfig = { servers: {} };
+
+	for (const [name, serverConfig] of Object.entries(config.servers)) {
+		result.servers[name] = substituteEnvVarsInObject(serverConfig) as ServerConfig;
+	}
+
+	// Process models config
+	if (config.models) {
+		result.models = substituteEnvVarsInObject(config.models);
+	}
+
+	return result;
+}
+
+function substituteEnvVarsInObject<T>(obj: T): T {
+	if (typeof obj === 'string') {
+		return obj.replace(/\$\{([^}]+)\}/g, (_, varName) => {
+			return process.env[varName] ?? '';
+		}) as T;
+	}
+	if (Array.isArray(obj)) {
+		return obj.map(substituteEnvVarsInObject) as T;
+	}
+	if (obj && typeof obj === 'object') {
+		const result: Record<string, unknown> = {};
+		for (const [key, value] of Object.entries(obj)) {
+			result[key] = substituteEnvVarsInObject(value);
+		}
+		return result as T;
+	}
+	return obj;
+}

package/src/server/db.ts

@@ -0,0 +1,115 @@
+import { MikroORM, type Options } from '@mikro-orm/core';
+import { SqliteDriver } from '@mikro-orm/sqlite';
+import { ChatRequestEntity } from '../entities/ChatRequestEntity';
+import { McpRequestEntity } from '../entities/McpRequestEntity';
+import { RequestLogEntity } from '../entities/RequestLogEntity';
+import { ResponseEntity } from '../entities/ResponseEntity';
+import type { DbConfig } from './schema';
+
+let orm: MikroORM<SqliteDriver> | null = null;
+let initPromise: Promise<MikroORM<SqliteDriver>> | null = null;
+let storedDbConfig: DbConfig | undefined;
+
+/**
+ * Get MikroORM configuration
+ */
+export function getOrmConfig(dbConfig?: DbConfig): Options<SqliteDriver> {
+	const dbPath = dbConfig?.path || '.mcps.db';
+
+	return {
+		driver: SqliteDriver,
+		dbName: dbPath,
+		entities: [ChatRequestEntity, McpRequestEntity, RequestLogEntity, ResponseEntity],
+		// Enable debug in development
+		debug: process.env.NODE_ENV === 'development',
+		// Allow global context for simpler usage
+		allowGlobalContext: true,
+	};
+}
+
+/**
+ * Initialize MikroORM and sync schema
+ */
+export async function initializeDb(dbConfig?: DbConfig): Promise<MikroORM<SqliteDriver>> {
+	if (orm) {
+		return orm;
+	}
+
+	// If already initializing, wait for the existing promise
+	if (initPromise) {
+		return initPromise;
+	}
+
+	storedDbConfig = dbConfig;
+
+	initPromise = (async () => {
+		const config = getOrmConfig(dbConfig);
+		orm = await MikroORM.init(config);
+
+		// Sync schema (create tables if not exist)
+		await orm.schema.update();
+
+		return orm;
+	})();
+
+	try {
+		return await initPromise;
+	} catch (e) {
+		// Reset on failure so retry is possible
+		initPromise = null;
+		throw e;
+	}
+}
+
+/**
+ * Configure DB for lazy initialization (stores config without initializing)
+ */
+export function configureDb(dbConfig?: DbConfig): void {
+	storedDbConfig = dbConfig;
+}
+
+/**
+ * Ensure DB is initialized (lazy init on first call)
+ * Returns the ORM instance, initializing if needed
+ */
+export async function ensureDbInitialized(): Promise<MikroORM<SqliteDriver>> {
+	if (orm) {
+		return orm;
+	}
+	return initializeDb(storedDbConfig);
+}
+
+/**
+ * Get MikroORM instance (must be initialized first)
+ */
+export function getOrm(): MikroORM<SqliteDriver> {
+	if (!orm) {
+		throw new Error('Database not initialized. Call initializeDb() first.');
+	}
+	return orm;
+}
+
+/**
+ * Get EntityManager
+ */
+export function getEntityManager() {
+	return getOrm().em;
+}
+
+/**
+ * Close database connection
+ */
+export async function closeDb(): Promise<void> {
+	if (orm) {
+		await orm.close();
+		orm = null;
+		initPromise = null;
+	}
+}
+
+/**
+ * Check if database is initialized
+ */
+export function isDbInitialized(): boolean {
+	return orm !== null;
+}

package/src/server/index.ts

@@ -0,0 +1 @@
+export { createServer } from './server';

package/src/server/mcp-handler.ts

@@ -0,0 +1,209 @@
+import type { StreamableHTTPTransport } from '@hono/mcp';
+import consola from 'consola';
+import { HeaderNames } from './schema';
+
+const mcpLog = consola.withTag('mcp');
+
+/**
+ * Tool annotation filter options
+ */
+export interface ToolFilterOptions {
+	/** Only include tools with readOnlyHint: true */
+	readonlyOnly?: boolean;
+	/** Include patterns (glob) */
+	includePatterns?: string[];
+	/** Exclude patterns (glob) */
+	excludePatterns?: string[];
+}
+
+/**
+ * Check if a pattern matches a string (simple glob support)
+ */
+function matchPattern(pattern: string, value: string): boolean {
+	// Convert glob to regex
+	const regex = new RegExp(`^${pattern.replace(/\*/g, '.*').replace(/\?/g, '.')}$`, 'i');
+	return regex.test(value);
+}
+
+/**
+ * Filter tools based on filter options
+ */
+export function filterTools(tools: any[], options: ToolFilterOptions): any[] {
+	let filtered = tools;
+
+	// Filter by readonly annotation
+	if (options.readonlyOnly) {
+		filtered = filtered.filter((tool) => {
+			const readOnlyHint = tool.annotations?.readOnlyHint;
+			return readOnlyHint === true;
+		});
+	}
+
+	// Filter by include patterns
+	if (options.includePatterns && options.includePatterns.length > 0) {
+		filtered = filtered.filter((tool) => options.includePatterns?.some((pattern) => matchPattern(pattern, tool.name)));
+	}
+
+	// Filter by exclude patterns
+	if (options.excludePatterns && options.excludePatterns.length > 0) {
+		filtered = filtered.filter((tool) => !options.excludePatterns?.some((pattern) => matchPattern(pattern, tool.name)));
+	}
+
+	return filtered;
+}
+
+/**
+ * Create a logging and filtering wrapper for MCP transport
+ * - Logs tool calls and their results with duration
+ * - Filters tools/list response based on X-MCP-Readonly, X-MCP-Include, X-MCP-Exclude headers
+ */
+export function createMcpLoggingHandler(transport: StreamableHTTPTransport, serverName: string) {
+	const originalHandleRequest = transport.handleRequest.bind(transport);
+
+	return async (c: Parameters<typeof transport.handleRequest>[0]) => {
+		const startTime = Date.now();
+
+		// Get filter headers
+		const readonlyHeader = c.req.header(HeaderNames.MCP_READONLY);
+		const includeHeader = c.req.header(HeaderNames.MCP_INCLUDE);
+		const excludeHeader = c.req.header(HeaderNames.MCP_EXCLUDE);
+
+		const filterOptions: ToolFilterOptions = {};
+		if (readonlyHeader?.toLowerCase() === 'true') {
+			filterOptions.readonlyOnly = true;
+		}
+		if (includeHeader) {
+			filterOptions.includePatterns = includeHeader.split(',').map((p) => p.trim());
+		}
+		if (excludeHeader) {
+			filterOptions.excludePatterns = excludeHeader.split(',').map((p) => p.trim());
+		}
+
+		const needsFiltering = filterOptions.readonlyOnly || filterOptions.includePatterns || filterOptions.excludePatterns;
+
+		// Log incoming request (clone body to avoid consuming it)
+		const contentType = c.req.header('content-type');
+		const isPost = c.req.method === 'POST';
+		let isToolsList = false;
+		let isToolsCall = false;
+		let toolName = '';
+		let parsedBody: any;
+
+		if (isPost && contentType?.includes('application/json')) {
+			try {
+				// Clone the request to read body without consuming it
+				const clonedReq = c.req.raw.clone();
+				parsedBody = await clonedReq.json();
+				// JSON-RPC request
+				if (parsedBody.method === 'tools/call' && parsedBody.params) {
+					const { name, arguments: args } = parsedBody.params;
+					toolName = name;
+					isToolsCall = true;
+					mcpLog.info(`→ [${serverName}] tools/call: ${name}`, args ? JSON.stringify(args).slice(0, 200) : '');
+				} else if (parsedBody.method === 'tools/list') {
+					mcpLog.debug(`→ [${serverName}] tools/list`);
+					isToolsList = true;
+				} else if (parsedBody.method) {
+					mcpLog.debug(`→ [${serverName}] ${parsedBody.method}`);
+				}
+			} catch {
+				// Ignore parse errors, let the transport handle them
+			}
+		}
+
+		// Call original handler with error handling
+		let response: Response | undefined;
+		try {
+			response = await originalHandleRequest(c);
+		} catch (e) {
+			const duration = Date.now() - startTime;
+			mcpLog.error(`✗ [${serverName}] handler error (${duration}ms):`, e);
+			throw e;
+		}
+
+		// For tools/call, we need to wait for the SSE stream to complete to get accurate duration
+		// Clone the response to read it without consuming the original
+		if (isToolsCall && response instanceof Response) {
+			const clonedResponse = response.clone();
+			// Read the cloned response in the background to measure actual duration
+			clonedResponse
+				.text()
+				.then(() => {
+					const duration = Date.now() - startTime;
+					mcpLog.info(`← [${serverName}] tools/call: ${toolName} (${duration}ms)`);
+				})
+				.catch(() => {
+					// Ignore read errors
+				});
+		}
+
+		// If this is a tools/list response and we need filtering, intercept and modify
+		if (isToolsList && needsFiltering && response instanceof Response) {
+			try {
+				const responseText = await response.clone().text();
+				const contentTypeHeader = response.headers.get('content-type') || '';
+
+				// Handle SSE format (event: message\ndata: {...})
+				if (contentTypeHeader.includes('text/event-stream')) {
+					// Parse SSE data - find the data line
+					const lines = responseText.split('\n');
+					let jsonData = '';
+					for (const line of lines) {
+						if (line.startsWith('data: ')) {
+							jsonData = line.slice(6);
+							break;
+						}
+					}
+
+					if (jsonData) {
+						const responseData = JSON.parse(jsonData);
+
+						if (responseData.result?.tools && Array.isArray(responseData.result.tools)) {
+							const originalCount = responseData.result.tools.length;
+							responseData.result.tools = filterTools(responseData.result.tools, filterOptions);
+							const filteredCount = responseData.result.tools.length;
+
+							if (filteredCount !== originalCount) {
+								mcpLog.info(
+									`← [${serverName}] tools/list: filtered ${originalCount} → ${filteredCount} tools (readonly=${filterOptions.readonlyOnly || false})`,
+								);
+							}
+
+							// Return new SSE response with filtered tools
+							const newSseData = `event: message\ndata: ${JSON.stringify(responseData)}\n\n`;
+							return new Response(newSseData, {
+								status: response.status,
+								headers: response.headers,
+							});
+						}
+					}
+				} else {
+					// Handle plain JSON response
+					const responseData = JSON.parse(responseText);
+
+					if (responseData.result?.tools && Array.isArray(responseData.result.tools)) {
+						const originalCount = responseData.result.tools.length;
+						responseData.result.tools = filterTools(responseData.result.tools, filterOptions);
+						const filteredCount = responseData.result.tools.length;
+
+						if (filteredCount !== originalCount) {
+							mcpLog.info(
+								`← [${serverName}] tools/list: filtered ${originalCount} → ${filteredCount} tools (readonly=${filterOptions.readonlyOnly || false})`,
+							);
+						}
+
+						return new Response(JSON.stringify(responseData), {
+							status: response.status,
+							headers: response.headers,
+						});
+					}
+				}
+			} catch (e) {
+				// If we can't parse/modify, return original
+				mcpLog.warn(`[${serverName}] Failed to filter tools/list response: ${e instanceof Error ? e.message : e}`);
+			}
+		}
+
+		return response;
+	};
+}