@wener/mcps 1.0.2 → 1.0.4

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('./server/audit-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

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/audit-db.ts

@@ -0,0 +1,65 @@
+import { MikroORM, type Options } from '@mikro-orm/core';
+import { SqliteDriver } from '@mikro-orm/sql';
+import { createSqliteDialect } from '@wener/server/mikro-orm';
+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';
+
+export { RequestLogEntity };
+
+let orm: MikroORM<SqliteDriver> | null = null;
+let initPromise: Promise<MikroORM<SqliteDriver>> | null = null;
+
+async function getOrmConfig(dbConfig?: DbConfig): Promise<Options<SqliteDriver>> {
+	const dbPath = dbConfig?.path || '.mcps.db';
+	return {
+		driver: SqliteDriver,
+		dbName: dbPath,
+		entities: [ChatRequestEntity, McpRequestEntity, RequestLogEntity, ResponseEntity],
+		driverOptions: await createSqliteDialect(dbPath),
+		debug: process.env.NODE_ENV === 'development',
+		allowGlobalContext: true,
+	};
+}
+
+export async function ensureDbInitialized(dbConfig?: DbConfig): Promise<MikroORM<SqliteDriver>> {
+	if (orm) return orm;
+	if (initPromise) return initPromise;
+
+	initPromise = (async () => {
+		const config = await getOrmConfig(dbConfig);
+		orm = await MikroORM.init(config);
+		await orm.schema.update();
+		return orm;
+	})();
+
+	try {
+		return await initPromise;
+	} catch (e) {
+		initPromise = null;
+		throw e;
+	}
+}
+
+export function getOrm(): MikroORM<SqliteDriver> {
+	if (!orm) throw new Error('Database not initialized');
+	return orm;
+}
+
+export function getEntityManager() {
+	return getOrm().em;
+}
+
+export async function closeDb(): Promise<void> {
+	if (orm) {
+		await orm.close();
+		orm = null;
+		initPromise = null;
+	}
+}
+
+export function isDbInitialized(): boolean {
+	return orm !== null;
+}

package/src/server/{audit.ts → audit-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 { McpsEventType, type McpsEmitter } from './events';
 import type { AuditConfig, DbConfig } from './schema';
+import type { McpsServerContext } from './server';
 
-/**
- * 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('./audit-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/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' },
+	});
+}