@wener/mcps 1.0.1

package/src/providers/sql/index.ts

@@ -0,0 +1 @@
+export { SqlMcpServerDef, SqlMcpServerHandlerDef } from './def';

package/src/providers/tencent-cls/def.ts

@@ -0,0 +1,38 @@
+import { TencentClsMcpServerDef, type CreateTencentClsMcpServerOptions } from '@wener/ai/mcp/tencent-cls';
+import { HeaderNames, type TencentClsConfig } from '../../server/schema';
+import { defineMcpServerHandler, registerMcpServerHandler } from '../McpServerHandlerDef';
+
+export const TencentClsMcpServerHandlerDef = defineMcpServerHandler<
+	CreateTencentClsMcpServerOptions,
+	TencentClsConfig
+>(TencentClsMcpServerDef, {
+	headerMappings: [
+		{ header: HeaderNames.CLS_SECRET_ID, property: 'clientId', required: true },
+		{ header: HeaderNames.CLS_SECRET_KEY, property: 'clientSecret', required: true },
+		{ header: HeaderNames.CLS_REGION, property: 'region', default: 'ap-shanghai' },
+		{ header: HeaderNames.CLS_ENDPOINT, property: 'endpoint' },
+	],
+
+	resolveConfig(config, headers) {
+		const clientId =
+			config.clientId || headers?.get(HeaderNames.CLS_SECRET_ID) || config.headers?.[HeaderNames.CLS_SECRET_ID];
+		const clientSecret =
+			config.clientSecret || headers?.get(HeaderNames.CLS_SECRET_KEY) || config.headers?.[HeaderNames.CLS_SECRET_KEY];
+		const region =
+			config.region ||
+			headers?.get(HeaderNames.CLS_REGION) ||
+			config.headers?.[HeaderNames.CLS_REGION] ||
+			'ap-shanghai';
+		const endpoint =
+			config.endpoint || headers?.get(HeaderNames.CLS_ENDPOINT) || config.headers?.[HeaderNames.CLS_ENDPOINT];
+
+		if (!clientId || !clientSecret) return null;
+
+		return { clientId, clientSecret, region, endpoint };
+	},
+});
+
+registerMcpServerHandler(TencentClsMcpServerHandlerDef);
+
+// backward compatibility
+export { TencentClsMcpServerHandlerDef as TencentClsMcpServerDef };

package/src/providers/tencent-cls/index.ts

@@ -0,0 +1 @@
+export { TencentClsMcpServerDef, TencentClsMcpServerHandlerDef } from './def';

package/src/scripts/bundle.ts

@@ -0,0 +1,82 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import * as esbuild from 'esbuild';
+
+const pkg = JSON.parse(fs.readFileSync('package.json', 'utf-8'));
+
+const banner = `// Bundled with esbuild
+// ${pkg.name}@${pkg.version}
+
+var require,__filename,__dirname;
+{
+  const {createRequire} = await import('node:module');
+  require ||= createRequire(import.meta.url);
+}
+{
+  const {fileURLToPath} = await import('node:url');
+  const {dirname} = await import('node:path');
+  __filename ||= fileURLToPath(import.meta.url);
+  __dirname ||= dirname(__filename)
+};
+`;
+
+const commonOptions: esbuild.BuildOptions = {
+	bundle: true,
+	logLevel: 'info',
+	banner: { js: banner },
+	define: {
+		NODE_ENV: JSON.stringify('production'),
+		__DEV__: JSON.stringify(false),
+		'process.env.NODE_ENV': JSON.stringify('production'),
+	},
+	keepNames: true,
+	treeShaking: true,
+	minifySyntax: true,
+	format: 'esm',
+	platform: 'node',
+	charset: 'utf8',
+	target: 'node18',
+	sourcemap: false,
+	legalComments: 'none',
+	// External native modules
+	external: ['better-sqlite3', 'oracledb', 'mariadb/callback', 'mysql'],
+};
+
+// Ensure dist directory exists
+fs.mkdirSync('dist', { recursive: true });
+
+console.log('Building MCPS...');
+
+// Build library entry (index.ts)
+const libResult = await esbuild.build({
+	...commonOptions,
+	entryPoints: ['src/index.ts'],
+	outfile: 'dist/index.mjs',
+});
+
+// Build CLI entry (mcps-cli.ts)
+const cliResult = await esbuild.build({
+	...commonOptions,
+	entryPoints: ['src/mcps-cli.ts'],
+	outfile: 'dist/mcps-cli.mjs',
+});
+
+if (libResult.errors.length === 0 && cliResult.errors.length === 0) {
+	// Process CLI output - add shebang
+	const cliOutfile = 'dist/mcps-cli.mjs';
+	let content = fs.readFileSync(cliOutfile, 'utf-8');
+	content = content.replace(/^#!.*\n/gm, '');
+	fs.writeFileSync(cliOutfile, `#!/usr/bin/env node\n${content}`);
+	fs.chmodSync(cliOutfile, 0o755);
+
+	const libStats = fs.statSync('dist/index.mjs');
+	const cliStats = fs.statSync(cliOutfile);
+
+	console.log(`✅ Build successful!`);
+	console.log(`📦 Library: dist/index.mjs (${(libStats.size / 1024).toFixed(1)}KB)`);
+	console.log(`📦 CLI: ${cliOutfile} (${(cliStats.size / 1024).toFixed(1)}KB)`);
+	console.log(`🚀 Ready for npm publish and npx usage`);
+} else {
+	console.error('❌ Build failed:', [...libResult.errors, ...cliResult.errors]);
+	process.exit(1);
+}

package/src/server/api-routes.ts

@@ -0,0 +1,98 @@
+import { SmartCoercionPlugin } from '@orpc/json-schema';
+import { OpenAPIGenerator } from '@orpc/openapi';
+import { OpenAPIHandler } from '@orpc/openapi/fetch';
+import { RPCHandler } from '@orpc/server/fetch';
+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';
+
+export interface RegisterApiRoutesOptions {
+	app: Hono;
+	config: McpsConfig;
+}
+
+/**
+ * Register oRPC API routes for audit and MCPS
+ */
+export function registerApiRoutes({ app, config }: RegisterApiRoutesOptions) {
+	// Create MCPS router with config context
+	const McpsRouter = createMcpsRouter({ config });
+
+	// Combined router for all APIs
+	const combinedRouter = {
+		audit: AuditRouter,
+		mcps: McpsRouter,
+	};
+
+	const handleByRpc = new RPCHandler(combinedRouter);
+	const handleByOpenAPI = new OpenAPIHandler(combinedRouter, {
+		plugins: [
+			new SmartCoercionPlugin({
+				schemaConverters: [new ZodToJsonSchemaConverter()],
+			}),
+			new CORSPlugin({
+				exposeHeaders: ['Content-Disposition'],
+			}),
+		],
+	});
+
+	app.use('/api/rpc/*', async (c, next) => {
+		const { matched, response } = await handleByRpc.handle(c.req.raw, {
+			prefix: '/api/rpc',
+			context: {},
+		});
+		if (matched) {
+			return c.newResponse(response.body, response);
+		}
+		return next();
+	});
+
+	app.use('/api/*', async (c, next) => {
+		const { matched, response } = await handleByOpenAPI.handle(c.req.raw, {
+			prefix: '/api',
+			context: {},
+		});
+		if (matched) {
+			return c.newResponse(response.body, response);
+		}
+		return next();
+	});
+
+	// OpenAPI spec
+	const openAPIGenerator = new OpenAPIGenerator({
+		schemaConverters: [new ZodToJsonSchemaConverter()],
+	});
+	let specCache: unknown;
+
+	app.get('/api/spec.json', async (c) => {
+		if (!specCache) {
+			specCache = await openAPIGenerator.generate(combinedRouter, {
+				info: { title: 'MCPS API', version: '1.0.0' },
+				servers: [{ url: '/api' }],
+			});
+		}
+		return c.json(specCache);
+	});
+
+	// Swagger UI
+	app.get('/api/docs', (c) => {
+		return c.html(
+			html`<!doctype html>
+				<html lang="en">
+					<head>
+						<title>MCPS API</title>
+						<meta charset="utf-8" />
+						<meta name="viewport" content="width=device-width, initial-scale=1" />
+					</head>
+					<body>
+						<script id="api-reference" data-url="/api/spec.json"></script>
+						<script src="https://cdn.jsdelivr.net/npm/@scalar/api-reference"></script>
+					</body>
+				</html>`,
+		);
+	});
+}

package/src/server/audit.ts

@@ -0,0 +1,310 @@
+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';
+
+/**
+ * Convert Headers to a plain record
+ */
+function headersToRecord(headers: Headers): Record<string, string> {
+	const record: Record<string, string> = {};
+	headers.forEach((value, key) => {
+		record[key] = value;
+	});
+	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
+});
+
+// Counter for IDs
+let eventCounter = 0;
+
+// Audit configuration state
+let auditEnabled = true; // default to enabled
+let dbConfigured = false;
+
+/**
+ * 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;
+	}
+
+	try {
+		// Lazy initialize DB on first persist
+		const orm = await ensureDbInitialized();
+		const em = orm.em.fork();
+
+		const logEntry = new RequestLogEntity();
+		logEntry.requestId = id;
+		logEntry.timestamp = new Date(event.timestamp);
+		logEntry.method = event.method;
+		logEntry.path = event.path;
+		logEntry.serverName = event.serverName ?? undefined;
+		logEntry.serverType = event.serverType ?? undefined;
+		logEntry.status = event.status ?? undefined;
+		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/')) {
+			logEntry.requestType = 'chat';
+		} else {
+			logEntry.requestType = 'api';
+		}
+		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
+	});
+
+	return fullEvent;
+}
+
+/**
+ * Query audit events
+ */
+export function queryAuditEvents(options: {
+	limit?: number;
+	offset?: number;
+	serverName?: string | null;
+	serverType?: string | null;
+	method?: string | null;
+	from?: string | null;
+	to?: string | null;
+}): { 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 (from) {
+		const fromTime = new Date(from).getTime();
+		events = events.filter((e) => new Date(e.timestamp).getTime() >= fromTime);
+	}
+	if (to) {
+		const toTime = new Date(to).getTime();
+		events = events.filter((e) => new Date(e.timestamp).getTime() <= toTime);
+	}
+
+	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);
+	}
+	if (options.to) {
+		const toTime = new Date(options.to).getTime();
+		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';
+		serverCounts.set(name, (serverCounts.get(name) || 0) + 1);
+	}
+	const byServer = Array.from(serverCounts.entries())
+		.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 byMethod = Array.from(methodCounts.entries())
+		.map(([method, count]) => ({ method, count }))
+		.sort((a, b) => b.count - a.count);
+
+	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;
+
+	for (const [id, event] of auditStore.entries()) {
+		if (new Date(event.timestamp).getTime() < beforeTime) {
+			auditStore.delete(id);
+			deleted++;
+		}
+	}
+
+	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 };
+	}),
+});
+
+/**
+ * Hono middleware for audit logging
+ */
+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';
+		}
+
+		// Extract model info from chat requests
+		if (path.startsWith('/v1/')) {
+			serverType = 'chat';
+		}
+
+		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),
+				});
+			}
+		}
+	};
+}

package/src/server/chat-routes.ts

@@ -0,0 +1,95 @@
+import consola from 'consola';
+import type { Hono } from 'hono';
+import { createChatHandler } from '../chat';
+import { registerAgentRoutes } from '../chat/agent';
+import type { McpsConfig, ModelConfig } from './schema';
+
+const log = consola.withTag('mcps');
+
+export interface RegisterChatRoutesOptions {
+	app: Hono;
+	config: McpsConfig;
+}
+
+/**
+ * Register Chat/LLM Gateway routes
+ */
+export function registerChatRoutes({ app, config }: RegisterChatRoutesOptions) {
+	if (!config.models || config.models.length === 0) {
+		return;
+	}
+
+	log.info(`Registering chat gateway with ${config.models.length} models`);
+	const chatHandler = createChatHandler({ config: { models: config.models } });
+	app.route('/', chatHandler);
+
+	// Helper function to resolve model config
+	function resolveModelConfig(modelName: string): ModelConfig | null {
+		const models = config.models || [];
+		// Exact match first
+		for (const modelConfig of models) {
+			if (modelConfig.name === modelName) return modelConfig;
+		}
+		// Wildcard match
+		for (const modelConfig of models) {
+			const pattern = modelConfig.name;
+			if (pattern.includes('*')) {
+				const regex = new RegExp(`^${pattern.replace(/\*/g, '.*')}$`);
+				if (regex.test(modelName)) return modelConfig;
+			}
+		}
+		return null;
+	}
+
+	// Register agent routes with tool loop support
+	registerAgentRoutes(app, {
+		resolveModelConfig,
+		// MCP tools will be loaded on-demand from configured servers
+		getMcpTools: async (serverNames) => {
+			if (!serverNames || serverNames.length === 0) {
+				return {};
+			}
+
+			const allTools: Record<string, any> = {};
+			const { createMCPClient } = await import('@ai-sdk/mcp');
+
+			for (const serverName of serverNames) {
+				const serverConfig = config.servers[serverName];
+				if (!serverConfig) {
+					log.warn(`MCP server not found: ${serverName}`);
+					continue;
+				}
+
+				try {
+					// Get the server URL - for configured servers, connect via HTTP
+					// The server exposes MCP at /mcp/{serverName}
+					const port = process.env.PORT || '3001';
+					const serverUrl = `http://127.0.0.1:${port}/mcp/${serverName}`;
+
+					// Create MCP client using SSE transport for HTTP-based MCP
+					const { SSEClientTransport } = await import('@modelcontextprotocol/sdk/client/sse.js');
+					const client = await createMCPClient({
+						transport: new SSEClientTransport(new URL(serverUrl)),
+					});
+
+					// Get tools from this server
+					const serverTools = await client.tools();
+					for (const [toolName, tool] of Object.entries(serverTools)) {
+						allTools[`${serverName}_${toolName}`] = tool;
+					}
+
+					log.info(`Loaded ${Object.keys(serverTools).length} tools from ${serverName}`);
+
+					// Close the client after getting tools
+					await client.close();
+				} catch (err) {
+					log.error(`Failed to load tools from ${serverName}:`, err);
+				}
+			}
+
+			log.info(`Agent loaded ${Object.keys(allTools).length} total tools from servers: ${serverNames.join(', ')}`);
+			return allTools;
+		},
+	});
+	log.info('Registered agent routes at /v1/agent/*');
+}