@wener/mcps 1.0.2 → 1.0.5

package/src/{server/audit.ts → audit/server/plugin.ts}

@@ -1,14 +1,10 @@
 import { implement } from '@orpc/server';
-import type { Context, Next } from 'hono';
 import { LRUCache } from 'lru-cache';
-import { AuditContract, type AuditEvent } from '../contracts';
-import { RequestLogEntity } from '../entities';
-import { ensureDbInitialized, configureDb } from './db';
-import type { AuditConfig, DbConfig } from './schema';
+import { McpsEventType } from '../../server/events';
+import type { AuditConfig, DbConfig } from '../../server/schema';
+import type { McpsServerContext } from '../../server/server';
+import { AuditContract, type AuditEvent } from '../AuditContract';
 
-/**
- * Convert Headers to a plain record
- */
 function headersToRecord(headers: Headers): Record<string, string> {
 	const record: Record<string, string> = {};
 	headers.forEach((value, key) => {
@@ -17,56 +13,22 @@ function headersToRecord(headers: Headers): Record<string, string> {
 	return record;
 }
 
-// In-memory audit store using LRU cache
 const auditStore = new LRUCache<string, AuditEvent>({
-	max: 10000, // Keep last 10k events
-	ttl: 1000 * 60 * 60 * 24, // 24 hours
+	max: 10000,
+	ttl: 1000 * 60 * 60 * 24,
 });
 
-// Counter for IDs
 let eventCounter = 0;
-
-// Audit configuration state
-let auditEnabled = true; // default to enabled
 let dbConfigured = false;
+let storedAuditConfig: AuditConfig | undefined;
+let storedDbConfig: DbConfig | undefined;
 
-/**
- * Configure audit module with settings
- * Call this before using audit features
- *
- * @param auditConfig - Audit config section
- * @param fallbackDbConfig - Fallback db config from root config
- */
-export function configureAudit(auditConfig?: AuditConfig, fallbackDbConfig?: DbConfig): void {
-	// Determine if audit is enabled (default: true)
-	auditEnabled = auditConfig?.enabled !== false;
-
-	if (auditEnabled) {
-		// Use audit.db config if present, otherwise fallback to root db config
-		const dbConfig = auditConfig?.db ?? fallbackDbConfig;
-		configureDb(dbConfig);
-		dbConfigured = true;
-	}
-}
-
-/**
- * Check if audit is enabled
- */
-export function isAuditEnabled(): boolean {
-	return auditEnabled;
-}
-
-/**
- * Persist audit event to database (lazy init)
- */
 async function persistToDb(event: AuditEvent, id: string): Promise<void> {
-	if (!auditEnabled || !dbConfigured) {
-		return;
-	}
+	if (!dbConfigured) return;
 
 	try {
-		// Lazy initialize DB on first persist
-		const orm = await ensureDbInitialized();
+		const { ensureDbInitialized, RequestLogEntity } = await import('./db.js');
+		const orm = await ensureDbInitialized(storedDbConfig);
 		const em = orm.em.fork();
 
 		const logEntry = new RequestLogEntity();
@@ -80,7 +42,6 @@ async function persistToDb(event: AuditEvent, id: string): Promise<void> {
 		logEntry.durationMs = event.durationMs ?? undefined;
 		logEntry.error = event.error ?? undefined;
 		logEntry.requestHeaders = event.requestHeaders ?? undefined;
-		// Determine request type
 		if (event.path.startsWith('/mcp/')) {
 			logEntry.requestType = 'mcp';
 		} else if (event.path.startsWith('/v1/')) {
@@ -91,30 +52,20 @@ async function persistToDb(event: AuditEvent, id: string): Promise<void> {
 		em.persist(logEntry);
 		await em.flush();
 	} catch (e) {
-		// Log persistence errors but don't throw - in-memory store is the primary
 		console.error('Failed to persist audit log:', e);
 	}
 }
 
-/**
- * Add an audit event
- */
 export function addAuditEvent(event: Omit<AuditEvent, 'id'>): AuditEvent {
 	const id = `${Date.now()}-${++eventCounter}`;
 	const fullEvent: AuditEvent = { ...event, id };
 	auditStore.set(id, fullEvent);
 
-	// Persist to database asynchronously (lazy init)
-	persistToDb(fullEvent, id).catch(() => {
-		// Already logged in persistToDb
-	});
+	persistToDb(fullEvent, id).catch(() => {});
 
 	return fullEvent;
 }
 
-/**
- * Query audit events
- */
 export function queryAuditEvents(options: {
 	limit?: number;
 	offset?: number;
@@ -126,25 +77,16 @@ export function queryAuditEvents(options: {
 }): { events: AuditEvent[]; total: number } {
 	const { limit = 50, offset = 0, serverName, serverType, method, from, to } = options;
 
-	// Get all events as array
 	let events: AuditEvent[] = [];
 	for (const [, event] of auditStore.entries()) {
 		events.push(event);
 	}
 
-	// Sort by timestamp desc
 	events.sort((a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime());
 
-	// Apply filters
-	if (serverName) {
-		events = events.filter((e) => e.serverName === serverName);
-	}
-	if (serverType) {
-		events = events.filter((e) => e.serverType === serverType);
-	}
-	if (method) {
-		events = events.filter((e) => e.method === method);
-	}
+	if (serverName) events = events.filter((e) => e.serverName === serverName);
+	if (serverType) events = events.filter((e) => e.serverType === serverType);
+	if (method) events = events.filter((e) => e.method === method);
 	if (from) {
 		const fromTime = new Date(from).getTime();
 		events = events.filter((e) => new Date(e.timestamp).getTime() >= fromTime);
@@ -155,23 +97,17 @@ export function queryAuditEvents(options: {
 	}
 
 	const total = events.length;
-
-	// Paginate
 	events = events.slice(offset, offset + limit);
 
 	return { events, total };
 }
 
-/**
- * Get audit statistics
- */
 export function getAuditStats(options: { from?: string | null; to?: string | null }) {
 	let events: AuditEvent[] = [];
 	for (const [, event] of auditStore.entries()) {
 		events.push(event);
 	}
 
-	// Apply time filters
 	if (options.from) {
 		const fromTime = new Date(options.from).getTime();
 		events = events.filter((e) => new Date(e.timestamp).getTime() >= fromTime);
@@ -181,14 +117,12 @@ export function getAuditStats(options: { from?: string | null; to?: string | nul
 		events = events.filter((e) => new Date(e.timestamp).getTime() <= toTime);
 	}
 
-	// Calculate stats
 	const totalRequests = events.length;
 	const totalErrors = events.filter((e) => e.error || (e.status && e.status >= 400)).length;
 
 	const durations = events.map((e) => e.durationMs).filter((d): d is number => d != null);
 	const avgDurationMs = durations.length > 0 ? durations.reduce((a, b) => a + b, 0) / durations.length : 0;
 
-	// Group by server
 	const serverCounts = new Map<string, number>();
 	for (const event of events) {
 		const name = event.serverName || 'unknown';
@@ -198,11 +132,10 @@ export function getAuditStats(options: { from?: string | null; to?: string | nul
 		.map(([name, count]) => ({ name, count }))
 		.sort((a, b) => b.count - a.count);
 
-	// Group by method
 	const methodCounts = new Map<string, number>();
 	for (const event of events) {
-		const method = event.method || 'unknown';
-		methodCounts.set(method, (methodCounts.get(method) || 0) + 1);
+		const m = event.method || 'unknown';
+		methodCounts.set(m, (methodCounts.get(m) || 0) + 1);
 	}
 	const byMethod = Array.from(methodCounts.entries())
 		.map(([method, count]) => ({ method, count }))
@@ -211,9 +144,6 @@ export function getAuditStats(options: { from?: string | null; to?: string | nul
 	return { totalRequests, totalErrors, avgDurationMs, byServer, byMethod };
 }
 
-/**
- * Clear audit events before a timestamp
- */
 export function clearAuditEvents(before: string): number {
 	const beforeTime = new Date(before).getTime();
 	let deleted = 0;
@@ -228,22 +158,16 @@ export function clearAuditEvents(before: string): number {
 	return deleted;
 }
 
-/**
- * Audit Router implementation
- */
 export const AuditRouter = implement(AuditContract).router({
 	list: implement(AuditContract.list).handler(async ({ input }) => {
 		return queryAuditEvents(input);
 	}),
-
 	get: implement(AuditContract.get).handler(async ({ input }) => {
 		return auditStore.get(input.id) ?? null;
 	}),
-
 	stats: implement(AuditContract.stats).handler(async ({ input }) => {
 		return getAuditStats(input);
 	}),
-
 	clear: implement(AuditContract.clear).handler(async ({ input }) => {
 		const deleted = clearAuditEvents(input.before);
 		return { deleted };
@@ -251,60 +175,63 @@ export const AuditRouter = implement(AuditContract).router({
 });
 
 /**
- * Hono middleware for audit logging
+ * Set up audit by subscribing to the server emitter.
+ * Call this from the `setup` callback of `createServer` to opt in to audit.
+ *
+ * @example
+ * ```ts
+ * createServer({
+ *   setup: (ctx) => {
+ *     setupAudit(ctx);
+ *   },
+ * });
+ * ```
  */
-export function auditMiddleware() {
-	return async (c: Context, next: Next) => {
-		const startTime = Date.now();
-		const path = c.req.path;
-
-		// Extract server info from path
-		let serverName: string | undefined;
-		let serverType: string | undefined;
-
-		const mcpMatch = path.match(/^\/mcp\/([^/]+)/);
-		if (mcpMatch) {
-			serverName = mcpMatch[1];
-			// Infer type from well-known paths
-			if (serverName === 'tencent-cls') serverType = 'tencent-cls';
-			else if (serverName === 'sql') serverType = 'sql';
-			else if (serverName === 'prometheus') serverType = 'prometheus';
-			else if (serverName === 'relay') serverType = 'relay';
-			else serverType = 'custom';
-		}
+export function setupAudit(ctx: McpsServerContext, options?: { auditConfig?: AuditConfig; dbConfig?: DbConfig }) {
+	const auditConfig = options?.auditConfig ?? ctx.config.audit;
+	const dbConfig = options?.dbConfig ?? ctx.config.db;
 
-		// Extract model info from chat requests
-		if (path.startsWith('/v1/')) {
-			serverType = 'chat';
-		}
+	const enabled = auditConfig?.enabled !== false;
+	if (!enabled) return;
 
-		let error: string | undefined;
-
-		try {
-			await next();
-		} catch (e) {
-			error = e instanceof Error ? e.message : String(e);
-			throw e;
-		} finally {
-			const durationMs = Date.now() - startTime;
-
-			// Audit MCP requests, Chat API requests, and other API requests
-			const shouldAudit =
-				path.startsWith('/mcp/') || path.startsWith('/v1/') || (path.startsWith('/api/') && c.req.method !== 'GET');
-
-			if (shouldAudit) {
-				addAuditEvent({
-					timestamp: new Date().toISOString(),
-					method: c.req.method,
-					path,
-					serverName,
-					serverType,
-					status: c.res.status,
-					durationMs,
-					error,
-					requestHeaders: headersToRecord(c.req.raw.headers),
-				});
-			}
+	const auditDbConfig = auditConfig?.db ?? dbConfig;
+	if (auditDbConfig) {
+		storedDbConfig = auditDbConfig;
+		dbConfigured = true;
+	}
+	storedAuditConfig = auditConfig;
+
+	// Subscribe to request events
+	ctx.emitter.on(McpsEventType.Request, (event) => {
+		const shouldAudit =
+			event.path.startsWith('/mcp/') ||
+			event.path.startsWith('/v1/') ||
+			(event.path.startsWith('/api/') && event.method !== 'GET');
+
+		if (shouldAudit) {
+			addAuditEvent({
+				timestamp: event.timestamp,
+				method: event.method,
+				path: event.path,
+				serverName: event.serverName,
+				serverType: event.serverType,
+				status: event.status,
+				durationMs: event.durationMs,
+				error: event.error,
+				requestHeaders: event.requestHeaders,
+			});
 		}
+	});
+
+	// Register audit API router
+	ctx.apiRouters.audit = AuditRouter;
+
+	// Register stats provider so mcps-router can access stats
+	ctx.statsProvider = {
+		getStats: getAuditStats,
+		queryEvents: (opts) => {
+			const result = queryAuditEvents(opts);
+			return { events: result.events.map((e) => ({ path: e.path })), total: result.total };
+		},
 	};
 }

package/src/chat/handler.ts

@@ -6,7 +6,7 @@ import consola from 'consola';
 import { Hono } from 'hono';
 import { streamSSE } from 'hono/streaming';
 import type { ChatConfig, ModelConfig } from '../server/schema';
-import { ChatProtocol, createAuditContext, extractClientIp } from './audit';
+import { ChatProtocol, createAuditContext, extractClientIp } from '../audit/chat';
 import {
 	openaiToAnthropicRequest,
 	anthropicToOpenaiResponse,
@@ -747,8 +747,8 @@ export function createChatHandler(options: ChatHandlerOptions = {}) {
 			let previousContext: { input: unknown; output: unknown[] } | null = null;
 			if (request.previous_response_id) {
 				try {
-					const { isDbInitialized, getEntityManager } = await import('../server/db');
-					const { ResponseEntity } = await import('../entities');
+					const { isDbInitialized, getEntityManager } = await import('../audit/server/db');
+					const { ResponseEntity } = await import('../audit/entities');
 					if (isDbInitialized()) {
 						const em = getEntityManager().fork();
 						const prevResponse = await em.findOne(ResponseEntity, { responseId: request.previous_response_id });
@@ -840,8 +840,8 @@ export function createChatHandler(options: ChatHandlerOptions = {}) {
 
 			// Store response for future previous_response_id lookups
 			try {
-				const { isDbInitialized, getEntityManager } = await import('../server/db');
-				const { ResponseEntity } = await import('../entities');
+				const { isDbInitialized, getEntityManager } = await import('../audit/server/db');
+				const { ResponseEntity } = await import('../audit/entities');
 				if (isDbInitialized()) {
 					const em = getEntityManager().fork();
 					const responseEntity = new ResponseEntity();

package/src/chat/index.ts

@@ -10,7 +10,7 @@ export * from './types';
 export * from './converters';
 
 // Audit
-export * from './audit';
+export * from '../audit/chat';
 
 // Handler
 export { createChatHandler, type ChatHandlerOptions } from './handler';

package/src/cli-start.ts

@@ -0,0 +1,43 @@
+import { serve } from '@hono/node-server';
+import consola from 'consola';
+import { createServer, type CreateServerOptions } from './server/server';
+
+const log = consola.withTag('mcps');
+
+let serverHandle: ReturnType<typeof serve> | undefined;
+
+function shutdown() {
+	log.info('Shutting down...');
+	if (serverHandle) {
+		serverHandle.close(() => process.exit(0));
+		setTimeout(() => process.exit(1), 3000);
+	} else {
+		process.exit(0);
+	}
+}
+
+process.on('SIGINT', shutdown);
+process.on('SIGTERM', shutdown);
+
+export async function startServer(options: { port: string; cwd: string; discoveryConfig: boolean; setup?: CreateServerOptions['setup'] }) {
+	const port = Number.parseInt(options.port, 10);
+	const { app, printEndpoints, finalize } = createServer({
+		cwd: options.cwd,
+		port,
+		discoveryConfig: options.discoveryConfig,
+		setup: options.setup,
+	});
+
+	await finalize();
+
+	log.info(`Starting MCPS server on port ${port}`);
+
+	serverHandle = serve({
+		fetch: app.fetch,
+		port,
+		hostname: '0.0.0.0',
+	});
+
+	log.success(`MCPS server running at http://localhost:${port}`);
+	printEndpoints();
+}

package/src/cli.ts

@@ -0,0 +1,45 @@
+import { Command } from 'commander';
+import type { CreateServerOptions } from './server/server';
+
+export interface CreateProgramOptions {
+	name?: string;
+	description?: string;
+	version?: string;
+	defaultPort?: string;
+	/** Called before the server starts, allows registering additional providers via side-effect imports */
+	beforeStart?: () => void | Promise<void>;
+	/** Server setup callback, passed to createServer. Use to register plugins like audit. */
+	setup?: CreateServerOptions['setup'];
+}
+
+/**
+ * Create a reusable Commander program for MCPS server.
+ * Consumers can register providers before calling `program.parseAsync()`.
+ */
+export function createProgram(options: CreateProgramOptions = {}): Command {
+	const {
+		name = 'mcps',
+		description = 'MCP Proxy Server - Unified MCP service with relay, SQL, CLS, and Prometheus support',
+		version = '0.1.0',
+		defaultPort = '8036',
+		beforeStart,
+		setup,
+	} = options;
+
+	const program = new Command();
+
+	program
+		.name(name)
+		.description(description)
+		.version(version)
+		.option('-p, --port <port>', 'Port to listen on', defaultPort)
+		.option('-c, --cwd <path>', 'Working directory for config files', process.cwd())
+		.option('--discovery-config', 'Enable server config discovery endpoints', false)
+		.action(async (opts) => {
+			await beforeStart?.();
+			const { startServer } = await import('./cli-start.js');
+			await startServer({ ...opts, setup });
+		});
+
+	return program;
+}

package/src/contracts/index.ts

@@ -1,4 +1,4 @@
-export { AuditContract, AuditEventSchema, AuditQuerySchema, AuditStatsSchema, type AuditEvent } from './AuditContract';
+export { AuditContract, AuditEventSchema, AuditQuerySchema, AuditStatsSchema, type AuditEvent } from '../audit/AuditContract';
 export {
 	McpsContract,
 	ServiceOverviewSchema,

package/src/dev.server.ts

@@ -1,6 +1,13 @@
+import { setupAudit } from '#/audit/server';
 import { createServer } from '#/server/server';
 
-const { app } = createServer({});
+const { app, finalize } = createServer({
+	setup: (ctx) => {
+		setupAudit(ctx);
+	},
+});
+
+await finalize();
 
 export default {
 	fetch: app.fetch,

package/src/entities/index.ts

@@ -1,12 +1,2 @@
-/**
- * Entity type definitions
- * These are pure TypeScript types without decorators
- * Can be used with any ORM or database layer
- */
-export * from './types';
-
-// MikroORM Entities
-export { ChatRequestEntity, ChatProtocolType, RequestStatus } from './ChatRequestEntity';
-export { McpRequestEntity, McpServerType, McpRequestType } from './McpRequestEntity';
-export { RequestLogEntity } from './RequestLogEntity';
-export { ResponseEntity } from './ResponseEntity';
+// Re-export from new location for backward compatibility
+export * from '../audit/entities/index';

package/src/index.ts

@@ -1 +1,47 @@
-export {};
+// Core server
+export { createServer, type CreateServerOptions, type McpsServerContext, type StatsProvider } from './server/server';
+
+// Events (emittery-based decoupling)
+export { McpsEventType, createMcpsEmitter, type McpsEmitter, type McpsEventData, type McpsRequestEvent } from './server/events';
+
+// Configuration
+export { loadConfig, substituteEnvVars, loadEnvFiles } from './server/config';
+export {
+	type McpsConfig,
+	type ServerConfig,
+	type ModelConfig,
+	type AuditConfig,
+	type DbConfig,
+	McpsConfigSchema,
+	ServerConfigSchema,
+	ModelConfigSchema,
+	AuditConfigSchema,
+	DbConfigSchema,
+	HeaderNames,
+} from './server/schema';
+
+// MCP routes and handler
+export { registerMcpRoutes } from './server/mcp-routes';
+export { registerChatRoutes } from './server/chat-routes';
+export { registerApiRoutes } from './server/api-routes';
+export { createMcpLoggingHandler } from './server/mcp-handler';
+export { createMcpsRouter } from './server/mcps-router';
+
+// Providers
+export {
+	type McpServerHandlerDef,
+	type McpServerHandlerDef as McpServerDef,
+	type HeaderMapping,
+	type DefineMcpServerHandlerOptions,
+	defineMcpServerHandler,
+	registerMcpServerHandler,
+	getAllMcpServerHandlerDefs,
+	getMcpServerHandlerDef,
+} from './providers/McpServerHandlerDef';
+export { findMcpServerDef, resolveMcpServerDef, getMcpServerDefCount } from './providers/findMcpServerDef';
+
+// Contracts
+export * from './contracts';
+
+// Chat
+export { createChatHandler, type ChatHandlerOptions } from './chat';

package/src/mcps-cli.ts

@@ -1,56 +1,14 @@
 #!/usr/bin/env node
-/**
- * MCPS - MCP Proxy Server CLI
- *
- * A unified MCP server that supports:
- * - Tencent CLS (Cloud Log Service)
- * - SQL (MySQL, PostgreSQL, SQLite)
- * - Prometheus
- * - Relay (proxy to other MCP servers)
- */
-import { serve } from '@hono/node-server';
-import { Command } from 'commander';
 import consola from 'consola';
-import { createServer } from './server/server';
+import { createProgram } from './cli';
 
 const log = consola.withTag('mcps');
 
-const program = new Command();
-
-program
-	.name('mcps')
-	.description('MCP Proxy Server - Unified MCP service with relay, SQL, CLS, and Prometheus support')
-	.version('0.1.0')
-	.option('-p, --port <port>', 'Port to listen on', '8036')
-	.option('-c, --cwd <path>', 'Working directory for config files', process.cwd())
-	.option('--discovery-config', 'Enable server config discovery endpoints', false)
-	.action(async (options) => {
-		const port = Number.parseInt(options.port, 10);
-		const { app } = createServer({
-			cwd: options.cwd,
-			port,
-			discoveryConfig: options.discoveryConfig,
-		});
-
-		log.info(`Starting MCPS server on port ${port}`);
-
-		serve({
-			fetch: app.fetch,
-			port,
-			hostname: '0.0.0.0',
-		});
-
-		log.success(`MCPS server running at http://localhost:${port}`);
-	});
-
-// Handle graceful shutdown
-process.on('SIGINT', () => {
-	log.info('Shutting down...');
-	process.exit(130);
-});
-process.on('SIGTERM', () => {
-	log.info('Shutting down...');
-	process.exit(143);
+const program = createProgram({
+	setup: async (ctx) => {
+		const { setupAudit } = await import('./audit/server/plugin.js');
+		setupAudit(ctx);
+	},
 });
 
 program.parseAsync(process.argv).catch((error) => {

package/src/providers/feishu/def.ts

@@ -0,0 +1,37 @@
+import { FeishuMcpServerDef, type CreateFeishuMcpServerOptions } from '@wener/ai/mcp/feishu';
+import { HeaderNames, type FeishuConfig } from '../../server/schema';
+import { defineMcpServerHandler, registerMcpServerHandler } from '../McpServerHandlerDef';
+
+export const FeishuMcpServerHandlerDef = defineMcpServerHandler<CreateFeishuMcpServerOptions, FeishuConfig>(
+	FeishuMcpServerDef,
+	{
+		headerMappings: [
+			{ header: HeaderNames.FEISHU_APP_ID, property: 'appId', required: true },
+			{ header: HeaderNames.FEISHU_APP_SECRET, property: 'appSecret', required: true },
+			{ header: HeaderNames.FEISHU_DOMAIN, property: 'domain' },
+		],
+
+		resolveConfig(config, headers) {
+			const appId =
+				config.appId ||
+				headers?.get(HeaderNames.FEISHU_APP_ID) ||
+				config.headers?.[HeaderNames.FEISHU_APP_ID];
+			const appSecret =
+				config.appSecret ||
+				headers?.get(HeaderNames.FEISHU_APP_SECRET) ||
+				config.headers?.[HeaderNames.FEISHU_APP_SECRET];
+
+			if (!appId || !appSecret) return null;
+
+			const domain =
+				config.domain ||
+				headers?.get(HeaderNames.FEISHU_DOMAIN) ||
+				config.headers?.[HeaderNames.FEISHU_DOMAIN] ||
+				'feishu';
+
+			return { appId, appSecret, domain };
+		},
+	},
+);
+
+registerMcpServerHandler(FeishuMcpServerHandlerDef);

package/src/providers/findMcpServerDef.ts

@@ -4,6 +4,7 @@ import './prometheus/def';
 import './tencent-cls/def';
 import './sql/def';
 import './relay/def';
+import './feishu/def';
 
 /**
  * Find MCP server definitions matching a predicate