@wener/mcps 1.0.2 → 1.0.5

package/src/scripts/bundle.ts

@@ -39,7 +39,18 @@ const commonOptions: esbuild.BuildOptions = {
 	sourcemap: false,
 	legalComments: 'none',
 	// External native modules
-	external: ['better-sqlite3', 'oracledb', 'mariadb/callback', 'mysql'],
+	external: [
+		'better-sqlite3',
+		'bun:sqlite',
+		'kysely-bun-sqlite',
+		'oracledb',
+		'mariadb/callback',
+		'mysql',
+		'@nestjs/websockets',
+		'@nestjs/microservices',
+		'@nestjs/platform-express',
+		'@larksuiteoapi/node-sdk',
+	],
 };
 
 // Ensure dist directory exists

package/src/server/api-routes.ts

@@ -6,26 +6,29 @@ import { CORSPlugin } from '@orpc/server/plugins';
 import { ZodToJsonSchemaConverter } from '@orpc/zod/zod4';
 import type { Hono } from 'hono';
 import { html } from 'hono/html';
-import { AuditRouter } from './audit';
 import { createMcpsRouter } from './mcps-router';
 import type { McpsConfig } from './schema';
+import type { StatsProvider } from './server';
 
 export interface RegisterApiRoutesOptions {
 	app: Hono;
 	config: McpsConfig;
+	/** Additional oRPC routers registered by plugins (e.g. audit) */
+	apiRouters?: Record<string, any>;
+	/** Optional stats provider from audit plugin */
+	statsProvider?: StatsProvider;
 }
 
 /**
- * Register oRPC API routes for audit and MCPS
+ * Register oRPC API routes for MCPS.
+ * Audit router is not included by default - use setupAudit() plugin to add it.
  */
-export function registerApiRoutes({ app, config }: RegisterApiRoutesOptions) {
-	// Create MCPS router with config context
-	const McpsRouter = createMcpsRouter({ config });
+export function registerApiRoutes({ app, config, apiRouters, statsProvider }: RegisterApiRoutesOptions) {
+	const McpsRouter = createMcpsRouter({ config, statsProvider });
 
-	// Combined router for all APIs
-	const combinedRouter = {
-		audit: AuditRouter,
+	const combinedRouter: Record<string, any> = {
 		mcps: McpsRouter,
+		...apiRouters,
 	};
 
 	const handleByRpc = new RPCHandler(combinedRouter);

package/src/server/events.ts

@@ -0,0 +1,29 @@
+import Emittery from 'emittery';
+
+export const McpsEventType = {
+	Request: 'Mcps:Request',
+} as const;
+
+export type McpsRequestEvent = {
+	timestamp: string;
+	method: string;
+	path: string;
+	serverName?: string;
+	serverType?: string;
+	status?: number;
+	durationMs?: number;
+	error?: string;
+	requestHeaders?: Record<string, string>;
+};
+
+export type McpsEventData = {
+	[McpsEventType.Request]: McpsRequestEvent;
+};
+
+export type McpsEmitter = Emittery<McpsEventData>;
+
+export function createMcpsEmitter(): McpsEmitter {
+	return new Emittery<McpsEventData>({
+		debug: { name: 'McpsEmitter' },
+	});
+}

package/src/server/mcp-routes.ts

@@ -17,13 +17,15 @@ export interface RegisterMcpRoutesOptions {
 }
 
 /**
- * Register MCP routes for both pre-configured and dynamic endpoints
+ * Register MCP routes for both pre-configured and dynamic endpoints.
+ *
+ * McpServer only supports one transport connection at a time, so we create
+ * a fresh server instance per request instead of caching stateful servers.
  */
-export function registerMcpRoutes({ app, config, serverCache }: RegisterMcpRoutesOptions) {
+export function registerMcpRoutes({ app, config, serverCache: _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) {
@@ -31,7 +33,6 @@ export function registerMcpRoutes({ app, config, serverCache }: RegisterMcpRoute
 			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}`);
@@ -44,48 +45,23 @@ export function registerMcpRoutes({ app, config, serverCache }: RegisterMcpRoute
 			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);
-			}
+			return handleMcpRequest(c, def, options, name);
 		});
 	}
 
-	// Register dynamic endpoints for all server types
-	// These endpoints accept config via HTTP headers
+	// Register dynamic endpoints for all server types (header-based config)
 	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)
@@ -94,40 +70,36 @@ export function registerMcpRoutes({ app, config, serverCache }: RegisterMcpRoute
 				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 handleMcpRequest(c, def, options, def.name);
 		});
 	}
 
 	return { serverDefs };
 }
+
+async function handleMcpRequest(c: any, def: McpServerHandlerDef, options: any, name: string) {
+	let item: McpServerInstance | undefined;
+	try {
+		item = def.create(options);
+		if (!item) return c.text(`Failed to create ${name} server`, 500);
+	} catch (e) {
+		log.error(`Failed to create ${name} server:`, e);
+		return c.text(`Failed to create ${name} server`, 500);
+	}
+
+	const transport = new StreamableHTTPTransport();
+	try {
+		await item.server.connect(transport);
+		const handleRequest = createMcpLoggingHandler(transport, name);
+		return await handleRequest(c);
+	} catch (e) {
+		log.error(`[${name}] Request error:`, e);
+		item.close?.().catch(() => {});
+		return c.text(`Internal server error: ${e instanceof Error ? e.message : 'Unknown error'}`, 500);
+	}
+}

package/src/server/mcps-router.ts

@@ -1,19 +1,17 @@
 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';
+import type { StatsProvider } from './server';
 
-// 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, '.*')
 		.replace(/\?/g, '.');
 	return new RegExp(`^${regexPattern}$`, 'i').test(text);
 }
 
-// Build server types from registry
 function getServerTypes(): ServerTypeInfo[] {
 	return findMcpServerDef().map((def) => ({
 		type: def.name,
@@ -22,7 +20,6 @@ function getServerTypes(): ServerTypeInfo[] {
 	}));
 }
 
-// Build endpoints from server types
 function getEndpoints(): string[] {
 	const mcpEndpoints = findMcpServerDef().map((def) => `/mcp/${def.name}`);
 	const chatEndpoints = [
@@ -38,22 +35,27 @@ function getEndpoints(): string[] {
 
 export interface McpsRouterContext {
 	config: McpsConfig;
+	/** Optional stats provider (e.g. from audit plugin) */
+	statsProvider?: StatsProvider;
 }
 
-/**
- * Create MCPS Router with config context
- */
+const emptyStats = {
+	totalRequests: 0,
+	totalErrors: 0,
+	avgDurationMs: 0,
+	byServer: [] as Array<{ name: string; count: number }>,
+	byMethod: [] as Array<{ method: string; count: number }>,
+};
+
 export function createMcpsRouter(ctx: McpsRouterContext) {
-	const { config } = ctx;
+	const { config, statsProvider } = 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,
@@ -76,10 +78,13 @@ export function createMcpsRouter(ctx: McpsRouterContext) {
 		}),
 
 		stats: implement(McpsContract.stats).handler(async ({ input }) => {
-			const auditStats = getAuditStats(input);
+			if (!statsProvider) {
+				return { ...emptyStats, byEndpoint: [] };
+			}
+
+			const auditStats = statsProvider.getStats(input);
+			const { events } = statsProvider.queryEvents({ limit: 10000 });
 
-			// 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';
@@ -88,12 +93,9 @@ export function createMcpsRouter(ctx: McpsRouterContext) {
 			const byEndpoint = Array.from(endpointCounts.entries())
 				.map(([endpoint, count]) => ({ endpoint, count }))
 				.sort((a, b) => b.count - a.count)
-				.slice(0, 20); // Top 20 endpoints
+				.slice(0, 20);
 
-			return {
-				...auditStats,
-				byEndpoint,
-			};
+			return { ...auditStats, byEndpoint };
 		}),
 
 		servers: implement(McpsContract.servers).handler(async () => {
@@ -105,17 +107,7 @@ export function createMcpsRouter(ctx: McpsRouterContext) {
 		}),
 
 		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) {

package/src/server/schema.ts

@@ -14,6 +14,9 @@ export const HeaderNames = {
 	MCP_URL: 'X-MCP-URL',
 	MCP_TYPE: 'X-MCP-TYPE',
 	MCP_COMMAND: 'X-MCP-COMMAND',
+	FEISHU_APP_ID: 'X-FEISHU-APP-ID',
+	FEISHU_APP_SECRET: 'X-FEISHU-APP-SECRET',
+	FEISHU_DOMAIN: 'X-FEISHU-DOMAIN',
 	// Tool filtering headers
 	MCP_READONLY: 'X-MCP-Readonly',
 	MCP_INCLUDE: 'X-MCP-Include',
@@ -53,6 +56,15 @@ export const PrometheusConfigSchema = BaseServerConfigSchema.extend({
 });
 export type PrometheusConfig = z.infer<typeof PrometheusConfigSchema>;
 
+// Feishu/Lark config
+export const FeishuConfigSchema = BaseServerConfigSchema.extend({
+	type: z.literal('feishu'),
+	appId: z.string().optional().describe('Feishu App ID'),
+	appSecret: z.string().optional().describe('Feishu App Secret'),
+	domain: z.string().optional().describe('feishu (China) or lark (International)'),
+});
+export type FeishuConfig = z.infer<typeof FeishuConfigSchema>;
+
 // Relay config for proxying to other MCP servers
 export const RelayConfigSchema = BaseServerConfigSchema.extend({
 	type: z.literal('relay'),
@@ -63,13 +75,22 @@ export const RelayConfigSchema = BaseServerConfigSchema.extend({
 });
 export type RelayConfig = z.infer<typeof RelayConfigSchema>;
 
-// Union of all server configs
-export const ServerConfigSchema = z.discriminatedUnion('type', [
+// Known server config schemas
+const KnownServerConfigSchema = z.discriminatedUnion('type', [
 	TencentClsConfigSchema,
 	SqlConfigSchema,
 	PrometheusConfigSchema,
+	FeishuConfigSchema,
 	RelayConfigSchema,
 ]);
+
+// Catch-all for custom/extension server types (e.g. platform-admin, fusionops-admin)
+const GenericServerConfigSchema = BaseServerConfigSchema.extend({
+	type: z.string(),
+}).passthrough();
+
+// Union of known types with generic fallback for extensibility
+export const ServerConfigSchema = z.union([KnownServerConfigSchema, GenericServerConfigSchema]);
 export type ServerConfig = z.infer<typeof ServerConfigSchema>;
 
 /**