@wener/mcps 1.0.1

package/src/server/mcp-routes.ts

@@ -0,0 +1,133 @@
+import { StreamableHTTPTransport } from '@hono/mcp';
+import consola from 'consola';
+import type { Hono } from 'hono';
+import type { LRUCache } from 'lru-cache';
+import type { McpServerInstance } from '@wener/ai/mcp';
+import { getMcpServerHandlerDef, type McpServerHandlerDef } from '../providers/McpServerHandlerDef';
+import { findMcpServerDef } from '../providers/findMcpServerDef';
+import { createMcpLoggingHandler } from './mcp-handler';
+import type { McpsConfig, ServerConfig } from './schema';
+
+const log = consola.withTag('mcps');
+
+export interface RegisterMcpRoutesOptions {
+	app: Hono;
+	config: McpsConfig;
+	serverCache: LRUCache<string, McpServerInstance>;
+}
+
+/**
+ * Register MCP routes for both pre-configured and dynamic endpoints
+ */
+export function registerMcpRoutes({ app, config, serverCache }: RegisterMcpRoutesOptions) {
+	const serverDefs = findMcpServerDef();
+
+	// Register pre-configured servers from config
+	// These are named endpoints like /mcp/my-sql that use config from file
+	for (const [name, serverConfig] of Object.entries(config.servers)) {
+		const def = getMcpServerHandlerDef(serverConfig.type);
+		if (!def) {
+			log.warn(`Unknown server type for ${name}: ${serverConfig.type}`);
+			continue;
+		}
+
+		// Resolve config using def (config comes from file, not headers)
+		const options = def.resolveConfig(serverConfig);
+		if (!options) {
+			log.warn(`Failed to resolve config for ${name}`);
+			continue;
+		}
+
+		const validation = def.validateOptions(options);
+		if (!validation.valid) {
+			log.warn(`Invalid config for ${name}: ${validation.error}`);
+			continue;
+		}
+
+		// Create and cache the server instance at startup
+		const cacheKey = `config::${name}`;
+		const item = def.create(options);
+		if (!item) {
+			log.warn(`Failed to create server: ${name}`);
+			continue;
+		}
+		serverCache.set(cacheKey, item);
+
+		const path = `/mcp/${name}`;
+		log.info(`Registered MCP server: ${path} (${serverConfig.type})`);
+
+		app.all(path, async (c) => {
+			const serverItem = serverCache.get(cacheKey);
+			if (!serverItem) {
+				return c.text('Server not found', 404);
+			}
+			// Create a new transport for each request to avoid "Transport already started" error
+			const transport = new StreamableHTTPTransport();
+			try {
+				await serverItem.server.connect(transport);
+				const handleRequest = createMcpLoggingHandler(transport, name);
+				return await handleRequest(c);
+			} catch (e) {
+				log.error(`[${name}] Request error:`, e);
+				return c.text(`Internal server error: ${e instanceof Error ? e.message : 'Unknown error'}`, 500);
+			}
+		});
+	}
+
+	// Register dynamic endpoints for all server types
+	// These endpoints accept config via HTTP headers
+	for (const def of serverDefs) {
+		const path = `/mcp/${def.name}`;
+		log.debug(`Registering dynamic endpoint: ${path}`);
+
+		app.all(path, async (c) => {
+			// Use def.resolveConfig to parse config from headers
+			const options = def.resolveConfig({ type: def.name } as any, c.req.raw.headers);
+
+			if (!options) {
+				// Build error message from headerMappings
+				const requiredHeaders =
+					def.headerMappings
+						?.filter((m) => m.required)
+						.map((m) => m.header)
+						.join(', ') || 'required headers';
+				return c.text(`Missing ${requiredHeaders}`, 400);
+			}
+
+			// Validate options
+			const validation = def.validateOptions(options);
+			if (!validation.valid) {
+				return c.text(validation.error || `Invalid configuration for ${def.name}`, 400);
+			}
+
+			// Get or create cached server instance
+			const key = def.getCacheKey(options);
+			let item = serverCache.get(key);
+			if (!item) {
+				log.info(`Creating new ${def.title} server: ${key}`);
+				try {
+					const newItem = def.create(options);
+					if (!newItem) return c.text(`Failed to create ${def.name} server`, 500);
+					item = newItem;
+					serverCache.set(key, item);
+				} catch (e) {
+					log.error(`Failed to create ${def.name} server:`, e);
+					return c.text(`Failed to create ${def.name} server`, 500);
+				}
+			}
+
+			// Create a new transport for each request
+			const transport = new StreamableHTTPTransport();
+			try {
+				await item.server.connect(transport);
+				const handleRequest = createMcpLoggingHandler(transport, def.name);
+				return await handleRequest(c);
+			} catch (e) {
+				log.error(`[${def.name}] Request error:`, e);
+				return c.text(`Internal server error: ${e instanceof Error ? e.message : 'Unknown error'}`, 500);
+			}
+		});
+	}
+
+	return { serverDefs };
+}

package/src/server/mcps-router.ts

@@ -0,0 +1,133 @@
+import { implement } from '@orpc/server';
+import { McpsContract, type ModelInfo, type ServerInfo, type ServerTypeInfo, type ToolInfo } from '../contracts';
+import { findMcpServerDef } from '../providers/findMcpServerDef';
+import { getAuditStats, queryAuditEvents } from './audit';
+import type { McpsConfig } from './schema';
+
+// Simple glob pattern matching
+function matchGlob(pattern: string, text: string): boolean {
+	const regexPattern = pattern
+		.replace(/[.+^${}()|[\]\\]/g, '\\$&') // Escape regex special chars except * and ?
+		.replace(/\*/g, '.*')
+		.replace(/\?/g, '.');
+	return new RegExp(`^${regexPattern}$`, 'i').test(text);
+}
+
+// Build server types from registry
+function getServerTypes(): ServerTypeInfo[] {
+	return findMcpServerDef().map((def) => ({
+		type: def.name,
+		description: def.description,
+		dynamicEndpoint: `/mcp/${def.name}`,
+	}));
+}
+
+// Build endpoints from server types
+function getEndpoints(): string[] {
+	const mcpEndpoints = findMcpServerDef().map((def) => `/mcp/${def.name}`);
+	const chatEndpoints = [
+		'/v1/chat/completions',
+		'/v1/messages',
+		'/v1/models',
+		'/v1/responses',
+		'/v1/models/:model:generateContent',
+		'/v1/models/:model:streamGenerateContent',
+	];
+	return [...mcpEndpoints, ...chatEndpoints];
+}
+
+export interface McpsRouterContext {
+	config: McpsConfig;
+}
+
+/**
+ * Create MCPS Router with config context
+ */
+export function createMcpsRouter(ctx: McpsRouterContext) {
+	const { config } = ctx;
+
+	// Build server info list
+	const servers: ServerInfo[] = Object.entries(config.servers).map(([name, serverConfig]) => ({
+		name,
+		type: serverConfig.type,
+		disabled: serverConfig.disabled,
+	}));
+
+	// Build model info list
+	const models: ModelInfo[] = (config.models ?? []).map((model) => ({
+		name: model.name,
+		adapter: model.adapter,
+		baseUrl: model.baseUrl,
+		contextWindow: model.contextWindow,
+		maxInputTokens: model.maxInputTokens,
+		maxOutputTokens: model.maxOutputTokens,
+	}));
+
+	return implement(McpsContract).router({
+		overview: implement(McpsContract.overview).handler(async () => {
+			return {
+				name: '@wener/mcps',
+				version: '0.1.0',
+				servers,
+				serverTypes: getServerTypes(),
+				models,
+				endpoints: getEndpoints(),
+			};
+		}),
+
+		stats: implement(McpsContract.stats).handler(async ({ input }) => {
+			const auditStats = getAuditStats(input);
+
+			// Build endpoint stats from audit events
+			const { events } = queryAuditEvents({ limit: 10000 });
+			const endpointCounts = new Map<string, number>();
+			for (const event of events) {
+				const endpoint = event.path || 'unknown';
+				endpointCounts.set(endpoint, (endpointCounts.get(endpoint) || 0) + 1);
+			}
+			const byEndpoint = Array.from(endpointCounts.entries())
+				.map(([endpoint, count]) => ({ endpoint, count }))
+				.sort((a, b) => b.count - a.count)
+				.slice(0, 20); // Top 20 endpoints
+
+			return {
+				...auditStats,
+				byEndpoint,
+			};
+		}),
+
+		servers: implement(McpsContract.servers).handler(async () => {
+			return { servers };
+		}),
+
+		models: implement(McpsContract.models).handler(async () => {
+			return { models };
+		}),
+
+		tools: implement(McpsContract.tools).handler(async ({ input }) => {
+			// TODO: This is a placeholder that returns empty tools list.
+			// Full implementation would require connecting to each MCP server
+			// and calling tools/list. Consider caching tool lists and
+			// refreshing periodically or on demand.
+			const tools: ToolInfo[] = [];
+
+			// For now, return an empty list.
+			// When MCP servers support persistent connections or when we
+			// implement a tool registry, this will be populated.
+
+			// Apply filters if provided
+			let filteredTools = tools;
+
+			if (input.server) {
+				filteredTools = filteredTools.filter((t) => t.serverName === input.server);
+			}
+
+			if (input.filter) {
+				const patterns = input.filter.split(',').map((p) => p.trim());
+				filteredTools = filteredTools.filter((t) => patterns.some((pattern) => matchGlob(pattern, t.name)));
+			}
+
+			return { tools: filteredTools };
+		}),
+	});
+}

package/src/server/schema.ts

@@ -0,0 +1,175 @@
+import { z } from 'zod';
+
+// Header name constants for config parsing
+export const HeaderNames = {
+	CLS_SECRET_ID: 'X-CLS-SECRET-ID',
+	CLS_SECRET_KEY: 'X-CLS-SECRET-KEY',
+	CLS_REGION: 'X-CLS-REGION',
+	CLS_ENDPOINT: 'X-CLS-ENDPOINT',
+	DB_URL: 'X-DB-URL',
+	DB_READ_URL: 'X-DB-READ-URL',
+	DB_WRITE_URL: 'X-DB-WRITE-URL',
+	SERVICE_URL: 'X-SERVICE-URL',
+	TOKEN: 'X-TOKEN',
+	MCP_URL: 'X-MCP-URL',
+	MCP_TYPE: 'X-MCP-TYPE',
+	MCP_COMMAND: 'X-MCP-COMMAND',
+	// Tool filtering headers
+	MCP_READONLY: 'X-MCP-Readonly',
+	MCP_INCLUDE: 'X-MCP-Include',
+	MCP_EXCLUDE: 'X-MCP-Exclude',
+} as const;
+
+// Base server config with common fields
+export const BaseServerConfigSchema = z.object({
+	disabled: z.boolean().optional(),
+	// Headers can be used as alternative to direct config properties
+	headers: z.record(z.string(), z.string()).optional(),
+});
+
+// Tencent CLS config - supports both direct config and headers
+export const TencentClsConfigSchema = BaseServerConfigSchema.extend({
+	type: z.literal('tencent-cls'),
+	clientId: z.string().optional().describe('Tencent Cloud Secret ID'),
+	clientSecret: z.string().optional().describe('Tencent Cloud Secret Key'),
+	region: z.string().optional().describe('CLS region'),
+	endpoint: z.string().optional().describe('CLS endpoint'),
+});
+export type TencentClsConfig = z.infer<typeof TencentClsConfigSchema>;
+
+// SQL config with read/write separation
+export const SqlConfigSchema = BaseServerConfigSchema.extend({
+	type: z.literal('sql'),
+	dbUrl: z.string().optional().describe('Database URL (for both read and write)'),
+	dbReadUrl: z.string().optional().describe('Database URL for read operations'),
+	dbWriteUrl: z.string().optional().describe('Database URL for write operations'),
+});
+export type SqlConfig = z.infer<typeof SqlConfigSchema>;
+
+// Prometheus config
+export const PrometheusConfigSchema = BaseServerConfigSchema.extend({
+	type: z.literal('prometheus'),
+	url: z.string().optional().describe('Prometheus server URL'),
+});
+export type PrometheusConfig = z.infer<typeof PrometheusConfigSchema>;
+
+// Relay config for proxying to other MCP servers
+export const RelayConfigSchema = BaseServerConfigSchema.extend({
+	type: z.literal('relay'),
+	url: z.string().optional().describe('Target MCP server URL'),
+	transport: z.enum(['http', 'sse']).optional().describe('MCP transport type'),
+	command: z.string().optional().describe('Command to run (stdio transport)'),
+	args: z.array(z.string()).optional().describe('Command arguments'),
+});
+export type RelayConfig = z.infer<typeof RelayConfigSchema>;
+
+// Union of all server configs
+export const ServerConfigSchema = z.discriminatedUnion('type', [
+	TencentClsConfigSchema,
+	SqlConfigSchema,
+	PrometheusConfigSchema,
+	RelayConfigSchema,
+]);
+export type ServerConfig = z.infer<typeof ServerConfigSchema>;
+
+/**
+ * Resolve config from headers - merge headers into config properties
+ * @deprecated Use McpServerDef.resolveConfig instead. This function is kept for backward compatibility.
+ */
+export function resolveServerConfig<T extends ServerConfig>(config: T): T {
+	// This function is now a pass-through - actual resolution is done in McpServerDef.resolveConfig
+	// Keeping it for backward compatibility with any external code that might use it
+	return config;
+}
+
+// ============================================================================
+// Chat/LLM Gateway Configuration
+// ============================================================================
+
+/**
+ * Adapter types for protocol conversion
+ */
+export const AdapterType = z.enum(['openai', 'anthropic', 'gemini']);
+export type AdapterType = z.infer<typeof AdapterType>;
+
+/**
+ * Adapter endpoint configuration for chat models
+ */
+export const AdapterEndpointConfigSchema = z.object({
+	baseUrl: z.string().optional(),
+	headers: z.record(z.string(), z.string()).optional(),
+	processors: z.array(z.string()).optional(),
+});
+export type AdapterEndpointConfig = z.infer<typeof AdapterEndpointConfigSchema>;
+
+/**
+ * Model configuration for chat gateway
+ */
+export const ModelConfigSchema = z.object({
+	/** Model name or pattern (supports wildcards like "gpt-*") */
+	name: z.string(),
+	/** Base URL for the API */
+	baseUrl: z.string().optional(),
+	/** API key (uses Authorization: Bearer header) */
+	apiKey: z.string().optional(),
+	/** Additional headers */
+	headers: z.record(z.string(), z.string()).optional(),
+	/** Default adapter to use for protocol conversion */
+	adapter: AdapterType.optional(),
+	/** Adapter-specific endpoint configurations */
+	adapters: z
+		.object({
+			openai: AdapterEndpointConfigSchema.optional(),
+			anthropic: AdapterEndpointConfigSchema.optional(),
+			gemini: AdapterEndpointConfigSchema.optional(),
+		})
+		.optional(),
+	/** Processor chain */
+	processors: z.array(z.string()).optional(),
+	/** Context window size (max total tokens) */
+	contextWindow: z.number().optional(),
+	/** Max input tokens */
+	maxInputTokens: z.number().optional(),
+	/** Max output tokens */
+	maxOutputTokens: z.number().optional(),
+	/** Whether to fetch models from upstream on /v1/models */
+	fetchUpstreamModels: z.boolean().optional(),
+});
+export type ModelConfig = z.infer<typeof ModelConfigSchema>;
+
+/**
+ * Database configuration for audit storage
+ */
+export const DbConfigSchema = z.object({
+	/** Path to SQLite database file (default: .mcps.db) */
+	path: z.string().optional(),
+});
+export type DbConfig = z.infer<typeof DbConfigSchema>;
+
+/**
+ * Audit configuration
+ */
+export const AuditConfigSchema = z.object({
+	/** Enable audit logging (default: true) */
+	enabled: z.boolean().optional(),
+	/** Database configuration for audit storage (overrides root db config) */
+	db: DbConfigSchema.optional(),
+});
+export type AuditConfig = z.infer<typeof AuditConfigSchema>;
+
+// Main config file schema
+export const McpsConfigSchema = z.object({
+	servers: z.record(z.string(), ServerConfigSchema).default({}),
+	/** Model configurations for chat gateway (array format) */
+	models: z.array(ModelConfigSchema).optional(),
+	/** Whether to expose server config discovery endpoints (default: false) */
+	discoveryConfig: z.boolean().optional(),
+	/** Database configuration (shared, used as fallback for audit.db) */
+	db: DbConfigSchema.optional(),
+	/** Audit configuration */
+	audit: AuditConfigSchema.optional(),
+});
+export type McpsConfig = z.infer<typeof McpsConfigSchema>;
+
+// Legacy ChatConfig type alias for backwards compatibility
+export type ChatConfig = { models?: ModelConfig[] };

package/src/server/server.ts

@@ -0,0 +1,163 @@
+import consola from 'consola';
+import { Hono } from 'hono';
+import { logger } from 'hono/logger';
+import { LRUCache } from 'lru-cache';
+import { isDevelopment } from 'std-env';
+import type { McpServerInstance } from '@wener/ai/mcp';
+import { findMcpServerDef } from '../providers/findMcpServerDef';
+import { registerApiRoutes } from './api-routes';
+import { auditMiddleware, configureAudit } from './audit';
+import { registerChatRoutes } from './chat-routes';
+import { loadConfig, loadEnvFiles, substituteEnvVars } from './config';
+import { registerMcpRoutes } from './mcp-routes';
+
+const log = consola.withTag('mcps');
+
+export interface CreateServerOptions {
+	cwd?: string;
+	port?: number;
+	/** Enable server config discovery endpoints (default: false) */
+	discoveryConfig?: boolean;
+}
+
+export function createServer(options: CreateServerOptions = {}) {
+	const { cwd = process.cwd(), discoveryConfig: discoveryConfigOption } = options;
+
+	const app = new Hono();
+
+	// Request logging
+	app.use(
+		logger((v) => {
+			log.debug(v);
+		}),
+	);
+
+	// Audit middleware
+	app.use(auditMiddleware());
+
+	// Load .env files first
+	loadEnvFiles(cwd);
+
+	// Load config (with env var substitution)
+	const config = substituteEnvVars(loadConfig(cwd));
+	// discoveryConfig: CLI option overrides config file, defaults to false
+	const discoveryConfig = discoveryConfigOption ?? config.discoveryConfig ?? false;
+
+	// Log available server types from registry
+	const serverDefs = findMcpServerDef();
+	log.info(`Available server types: ${serverDefs.map((d) => d.name).join(', ')}`);
+	log.info(`Loaded ${Object.keys(config.servers).length} servers from config (discoveryConfig: ${discoveryConfig})`);
+
+	// Configure audit with lazy DB initialization
+	// DB will only be initialized when the first audit event needs persistence
+	configureAudit(config.audit, config.db);
+	const auditEnabled = config.audit?.enabled !== false;
+	const auditDbPath = config.audit?.db?.path ?? config.db?.path ?? '.mcps.db';
+	log.info(`Audit configured: enabled=${auditEnabled}, db=${auditDbPath} (lazy init)`);
+
+	// Unified cache for all MCP servers (both pre-configured and dynamic)
+	// Keyed by cache key from def.getCacheKey() or `config::${name}` for pre-configured
+	const serverCache = new LRUCache<string, McpServerInstance>({
+		max: 100,
+		dispose: (value, key) => {
+			log.info(`Closing expired MCP server: ${key}`);
+			value.close?.().catch((e: unknown) => log.error('Failed to close server', e));
+		},
+	});
+
+	// =========================================================================
+	// Register MCP routes (pre-configured and dynamic endpoints)
+	// =========================================================================
+	registerMcpRoutes({ app, config, serverCache });
+
+	// =========================================================================
+	// Register Chat/LLM Gateway routes
+	// =========================================================================
+	registerChatRoutes({ app, config });
+
+	// =========================================================================
+	// Health and info endpoints
+	// =========================================================================
+	app.get('/health', (c) => c.json({ status: 'ok' }));
+
+	app.get('/', (c) => {
+		return c.json({ message: 'hello' });
+	});
+
+	// Server info - only available in dev mode or when discoveryConfig is enabled
+	if (isDevelopment || discoveryConfig) {
+		app.get('/info', (c) => {
+			// Dynamically get routes from Hono app
+			const routes = app.routes
+				.map((r) => ({ method: r.method, path: r.path }))
+				.filter((r) => r.method !== 'ALL' || r.path.startsWith('/mcp/'))
+				.sort((a, b) => a.path.localeCompare(b.path) || a.method.localeCompare(b.method));
+
+			// Group routes by category
+			const mcpRoutes = routes.filter((r) => r.path.startsWith('/mcp/')).map((r) => r.path);
+			const apiRoutes = routes.filter((r) => r.path.startsWith('/api/')).map((r) => `${r.method} ${r.path}`);
+			const chatRoutes = routes.filter((r) => r.path.startsWith('/v1/')).map((r) => `${r.method} ${r.path}`);
+
+			// Get unique MCP paths
+			const uniqueMcpPaths = [...new Set(mcpRoutes)];
+
+			return c.json({
+				name: '@wener/mcps',
+				version: '0.1.0',
+				servers: Object.keys(config.servers),
+				serverTypes: findMcpServerDef().map((d) => d.name),
+				models: config.models ? config.models.map((m) => m.name) : [],
+				endpoints: {
+					mcp: uniqueMcpPaths,
+					api: [...new Set(apiRoutes)],
+					chat: [...new Set(chatRoutes)],
+				},
+			});
+		});
+	}
+
+	// =========================================================================
+	// Register oRPC API routes
+	// =========================================================================
+	registerApiRoutes({ app, config });
+
+	/**
+	 * Print available endpoints grouped by category
+	 */
+	const printEndpoints = () => {
+		const routes = app.routes;
+		const mcpPaths = new Set<string>();
+		const apiPaths = new Set<string>();
+		const chatPaths = new Set<string>();
+		const otherPaths = new Set<string>();
+
+		for (const route of routes) {
+			const path = route.path;
+			if (path.startsWith('/mcp/')) {
+				mcpPaths.add(path);
+			} else if (path.startsWith('/api/')) {
+				apiPaths.add(`${route.method} ${path}`);
+			} else if (path.startsWith('/v1/')) {
+				chatPaths.add(`${route.method} ${path}`);
+			} else if (route.method !== 'ALL') {
+				otherPaths.add(`${route.method} ${path}`);
+			}
+		}
+
+		log.info('Available endpoints:');
+		if (mcpPaths.size > 0) {
+			log.info(`  MCP: ${[...mcpPaths].sort().join(', ')}`);
+		}
+		if (chatPaths.size > 0) {
+			log.info(`  Chat: ${[...chatPaths].sort().join(', ')}`);
+		}
+		if (apiPaths.size > 0) {
+			log.info(`  API: ${[...apiPaths].sort().join(', ')}`);
+		}
+		if (otherPaths.size > 0) {
+			log.info(`  Other: ${[...otherPaths].sort().join(', ')}`);
+		}
+	};
+
+	return { app, config, serverCache, printEndpoints };
+}