@wener/mcps 1.0.1

package/src/entities/RequestLogEntity.ts

@@ -0,0 +1,78 @@
+import { Entity, PrimaryKey, Property } from '@mikro-orm/decorators/es';
+
+/**
+ * Generic HTTP Request Log Entity
+ * For general request auditing
+ */
+@Entity({ tableName: 'request_log' })
+export class RequestLogEntity {
+	@PrimaryKey({ type: 'integer' })
+	id!: number;
+
+	/** Unique request ID */
+	@Property({ type: 'string' })
+	requestId!: string;
+
+	/** Request timestamp */
+	@Property({ type: 'datetime' })
+	timestamp: Date = new Date();
+
+	/** HTTP method */
+	@Property({ type: 'string' })
+	method!: string;
+
+	/** Request path */
+	@Property({ type: 'string' })
+	path!: string;
+
+	/** Request type (chat, mcp, api, etc) */
+	@Property({ type: 'string', nullable: true })
+	requestType?: string;
+
+	/** Server name (for MCP) or model (for Chat) */
+	@Property({ type: 'string', nullable: true })
+	serverName?: string;
+
+	/** Server type */
+	@Property({ type: 'string', nullable: true })
+	serverType?: string;
+
+	/** HTTP status code */
+	@Property({ type: 'integer', nullable: true })
+	status?: number;
+
+	/** Request duration in ms */
+	@Property({ type: 'integer', nullable: true })
+	durationMs?: number;
+
+	/** Error message */
+	@Property({ type: 'text', nullable: true })
+	error?: string;
+
+	/** Client IP */
+	@Property({ type: 'string', nullable: true })
+	clientIp?: string;
+
+	/** User agent */
+	@Property({ type: 'string', nullable: true })
+	userAgent?: string;
+
+	/** Request headers (JSON) */
+	@Property({ type: 'json', nullable: true })
+	requestHeaders?: Record<string, string>;
+
+	/** Request body summary (JSON) */
+	@Property({ type: 'json', nullable: true })
+	requestBody?: Record<string, unknown>;
+
+	/** Response body summary (JSON) */
+	@Property({ type: 'json', nullable: true })
+	responseBody?: Record<string, unknown>;
+
+	/** Additional metadata (JSON) */
+	@Property({ type: 'json', nullable: true })
+	metadata?: Record<string, unknown>;
+
+	@Property({ type: 'datetime' })
+	createdAt: Date = new Date();
+}

package/src/entities/ResponseEntity.ts

@@ -0,0 +1,75 @@
+import { Entity, PrimaryKey, Property } from '@mikro-orm/decorators/es';
+
+/**
+ * Response Entity for storing Responses API responses
+ * Enables previous_response_id support
+ */
+@Entity({ tableName: 'response' })
+export class ResponseEntity {
+	@PrimaryKey({ type: 'integer' })
+	id!: number;
+
+	/** Response ID (e.g., resp_xxx) */
+	@Property({ type: 'string', unique: true })
+	responseId!: string;
+
+	/** Model name */
+	@Property({ type: 'string' })
+	model!: string;
+
+	/** Response status */
+	@Property({ type: 'string' })
+	status!: string;
+
+	/** Input (request) - stored as JSON */
+	@Property({ type: 'json' })
+	input!: unknown;
+
+	/** Output items - stored as JSON */
+	@Property({ type: 'json' })
+	output!: unknown[];
+
+	/** Usage statistics */
+	@Property({ type: 'json', nullable: true })
+	usage?: {
+		prompt_tokens?: number;
+		completion_tokens?: number;
+		total_tokens?: number;
+	};
+
+	/** Instructions/system prompt */
+	@Property({ type: 'text', nullable: true })
+	instructions?: string;
+
+	/** Previous response ID for conversation chaining */
+	@Property({ type: 'string', nullable: true })
+	previousResponseId?: string;
+
+	/** Tools configuration */
+	@Property({ type: 'json', nullable: true })
+	tools?: unknown[];
+
+	/** Tool choice */
+	@Property({ type: 'json', nullable: true })
+	toolChoice?: unknown;
+
+	/** Metadata */
+	@Property({ type: 'json', nullable: true })
+	metadata?: Record<string, unknown>;
+
+	/** Error information */
+	@Property({ type: 'json', nullable: true })
+	error?: {
+		type?: string;
+		message?: string;
+		code?: string;
+	};
+
+	/** Created timestamp */
+	@Property({ type: 'datetime' })
+	createdAt: Date = new Date();
+
+	/** Request duration in ms */
+	@Property({ type: 'integer', nullable: true })
+	durationMs?: number;
+}

package/src/entities/index.ts

@@ -0,0 +1,12 @@
+/**
+ * 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';

package/src/entities/types.ts

@@ -0,0 +1,188 @@
+/**
+ * Entity Type Definitions
+ * These types can be used with MikroORM or other ORMs
+ * Avoids decorator issues in test environments
+ */
+
+/**
+ * Base entity fields
+ */
+export interface BaseEntity {
+	id: number;
+	createdAt: Date;
+	updatedAt: Date;
+}
+
+/**
+ * Request status
+ */
+export type RequestStatus = 'pending' | 'success' | 'error' | 'timeout';
+
+/**
+ * Chat protocol type
+ */
+export type ChatProtocolType = 'openai' | 'anthropic' | 'gemini';
+
+/**
+ * MCP server type
+ */
+export type McpServerType = 'tencent-cls' | 'sql' | 'prometheus' | 'relay' | 'custom';
+
+/**
+ * MCP request type
+ */
+export type McpRequestType =
+	| 'initialize'
+	| 'tools/list'
+	| 'tools/call'
+	| 'resources/list'
+	| 'resources/read'
+	| 'prompts/list'
+	| 'prompts/get'
+	| 'completion/complete'
+	| 'logging/setLevel'
+	| 'ping'
+	| 'other';
+
+/**
+ * Chat request entity for auditing and metering
+ */
+export interface ChatRequest extends BaseEntity {
+	/** Unique request ID for tracing */
+	requestId: string;
+	/** Request timestamp */
+	requestedAt: Date;
+	/** Response timestamp */
+	completedAt?: Date;
+	/** Request status */
+	status: RequestStatus;
+	/** HTTP method */
+	method: string;
+	/** Request path/endpoint */
+	endpoint: string;
+	/** Input protocol (client-facing) */
+	inputProtocol: ChatProtocolType;
+	/** Output protocol (upstream provider) */
+	outputProtocol: ChatProtocolType;
+	/** Model name requested */
+	model: string;
+	/** Resolved model name */
+	resolvedModel?: string;
+	/** Provider name */
+	provider?: string;
+	/** Upstream base URL */
+	upstreamUrl?: string;
+	/** Whether request was streaming */
+	streaming: boolean;
+	/** Input token count */
+	inputTokens?: number;
+	/** Output token count */
+	outputTokens?: number;
+	/** Total token count */
+	totalTokens?: number;
+	/** Request duration in ms */
+	durationMs?: number;
+	/** Time to first token in ms */
+	ttftMs?: number;
+	/** HTTP status code */
+	httpStatus?: number;
+	/** Error message */
+	errorMessage?: string;
+	/** Error code */
+	errorCode?: string;
+	/** Client IP */
+	clientIp?: string;
+	/** User agent */
+	userAgent?: string;
+	/** User ID */
+	userId?: string;
+	/** Organization ID */
+	orgId?: string;
+	/** API key ID (not the actual key) */
+	apiKeyId?: string;
+	/** Request metadata */
+	requestMeta?: Record<string, unknown>;
+	/** Response metadata */
+	responseMeta?: Record<string, unknown>;
+	/** Cost in credits */
+	cost?: string;
+	/** Currency */
+	currency?: string;
+}
+
+/**
+ * MCP request entity for auditing
+ */
+export interface McpRequest extends BaseEntity {
+	/** Unique request ID */
+	requestId: string;
+	/** MCP session ID */
+	sessionId?: string;
+	/** Request timestamp */
+	requestedAt: Date;
+	/** Response timestamp */
+	completedAt?: Date;
+	/** Request status */
+	status: RequestStatus;
+	/** HTTP method */
+	method: string;
+	/** Request path */
+	path: string;
+	/** MCP server name */
+	serverName: string;
+	/** MCP server type */
+	serverType: McpServerType;
+	/** MCP request type */
+	mcpMethod: McpRequestType;
+	/** Tool name (for tools/call) */
+	toolName?: string;
+	/** Resource URI (for resources/read) */
+	resourceUri?: string;
+	/** Prompt name (for prompts/get) */
+	promptName?: string;
+	/** Request duration in ms */
+	durationMs?: number;
+	/** HTTP status code */
+	httpStatus?: number;
+	/** Error message */
+	errorMessage?: string;
+	/** Error code */
+	errorCode?: string;
+	/** Client IP */
+	clientIp?: string;
+	/** User agent */
+	userAgent?: string;
+	/** User ID */
+	userId?: string;
+	/** Request headers */
+	requestHeaders?: Record<string, string>;
+	/** Request body */
+	requestBody?: Record<string, unknown>;
+	/** Response metadata */
+	responseMeta?: Record<string, unknown>;
+}
+
+/**
+ * Chat audit statistics
+ */
+export interface ChatAuditStats {
+	totalRequests: number;
+	successfulRequests: number;
+	failedRequests: number;
+	totalInputTokens: number;
+	totalOutputTokens: number;
+	avgDurationMs: number;
+	byModel: { model: string; count: number; tokens: number }[];
+	byProvider: { provider: string; count: number; tokens: number }[];
+}
+
+/**
+ * MCP audit statistics
+ */
+export interface McpAuditStats {
+	totalRequests: number;
+	totalErrors: number;
+	avgDurationMs: number;
+	byServer: { name: string; count: number }[];
+	byMethod: { method: string; count: number }[];
+}

package/src/index.ts

@@ -0,0 +1 @@
+export {};

package/src/mcps-cli.ts

@@ -0,0 +1,59 @@
+#!/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';
+
+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);
+});
+
+program.parseAsync(process.argv).catch((error) => {
+	log.error(error.message);
+	process.exit(1);
+});

package/src/providers/McpServerHandlerDef.ts

@@ -0,0 +1,105 @@
+import type { McpServerDef, McpServerInstance, ValidationResult } from '@wener/ai/mcp';
+
+/**
+ * Header to config property mapping
+ */
+export interface HeaderMapping {
+	/** Header name (e.g., 'X-CLS-SECRET-ID') */
+	header: string;
+	/** Config property name (e.g., 'clientId') */
+	property: string;
+	/** Whether this header/property is required */
+	required?: boolean;
+	/** Default value if not provided */
+	default?: string;
+}
+
+/**
+ * MCP Server Handler Definition - wraps a McpServerDef with HTTP header handling
+ */
+export interface McpServerHandlerDef<TOptions = any, TConfig = any> {
+	/** Reference to the base MCP server definition */
+	base: McpServerDef<TOptions>;
+
+	/** Unique server type name */
+	name: string;
+	/** Display name */
+	title: string;
+	/** Server description */
+	description: string;
+	/** Server version */
+	version: string;
+	/** Tags for categorization */
+	tags: string[];
+	/** Additional metadata */
+	metadata: Record<string, any>;
+
+	/** Header mappings for dynamic endpoint */
+	headerMappings?: HeaderMapping[];
+
+	/** Resolve config from ServerConfig and optional Headers */
+	resolveConfig: (config: TConfig, headers?: Headers) => TOptions | null;
+
+	/** Validate resolved options */
+	validateOptions: (options: Partial<TOptions>) => ValidationResult;
+
+	/** Generate cache key for server instance caching */
+	getCacheKey: (options: TOptions) => string;
+
+	/** Factory function to create the server instance */
+	create: (options: TOptions) => McpServerInstance;
+}
+
+export interface DefineMcpServerHandlerOptions<TOptions = any, TConfig = any> {
+	/** Header mappings for dynamic endpoint */
+	headerMappings?: HeaderMapping[];
+
+	/** Resolve config from ServerConfig and optional Headers */
+	resolveConfig: (config: TConfig, headers?: Headers) => TOptions | null;
+}
+
+/**
+ * Define an MCP server handler by wrapping a base McpServerDef with HTTP header handling
+ */
+export function defineMcpServerHandler<TOptions = any, TConfig = any>(
+	base: McpServerDef<TOptions>,
+	options: DefineMcpServerHandlerOptions<TOptions, TConfig>,
+): McpServerHandlerDef<TOptions, TConfig> {
+	return {
+		base,
+		name: base.name,
+		title: base.title,
+		description: base.description,
+		version: base.version,
+		tags: [...base.tags],
+		metadata: { ...base.metadata },
+		headerMappings: options.headerMappings,
+		resolveConfig: options.resolveConfig,
+		validateOptions: base.validateOptions,
+		getCacheKey: base.getCacheKey,
+		create: base.create,
+	};
+}
+
+const _all: McpServerHandlerDef[] = [];
+
+/**
+ * Register an MCP server handler definition
+ */
+export function registerMcpServerHandler(def: McpServerHandlerDef): void {
+	_all.push(def);
+}
+
+/**
+ * Get all registered MCP server handler definitions
+ */
+export function getAllMcpServerHandlerDefs(): McpServerHandlerDef[] {
+	return _all;
+}
+
+/**
+ * Find MCP server handler definition by name
+ */
+export function getMcpServerHandlerDef(name: string): McpServerHandlerDef | undefined {
+	return _all.find((def) => def.name === name);
+}

package/src/providers/findMcpServerDef.ts

@@ -0,0 +1,31 @@
+import { getAllMcpServerHandlerDefs, type McpServerHandlerDef } from './McpServerHandlerDef';
+// Import all server definitions to ensure they are registered
+import './prometheus/def';
+import './tencent-cls/def';
+import './sql/def';
+import './relay/def';
+
+/**
+ * Find MCP server definitions matching a predicate
+ */
+export function findMcpServerDef(predicate?: (def: McpServerHandlerDef) => boolean): McpServerHandlerDef[] {
+	const all = getAllMcpServerHandlerDefs();
+	if (!predicate) {
+		return all;
+	}
+	return all.filter(predicate);
+}
+
+/**
+ * Resolve a single MCP server definition by name
+ */
+export function resolveMcpServerDef(name: string): McpServerHandlerDef | undefined {
+	return findMcpServerDef((v) => v.name === name)[0];
+}
+
+/**
+ * Get total count of registered MCP server types
+ */
+export function getMcpServerDefCount(): number {
+	return getAllMcpServerHandlerDefs().length;
+}

package/src/providers/prometheus/def.ts

@@ -0,0 +1,21 @@
+import { PrometheusMcpServerDef, type CreatePrometheusMcpServerOptions } from '@wener/ai/mcp/prometheus';
+import { HeaderNames, type PrometheusConfig } from '../../server/schema';
+import { defineMcpServerHandler, registerMcpServerHandler } from '../McpServerHandlerDef';
+
+export const PrometheusMcpServerHandlerDef = defineMcpServerHandler<CreatePrometheusMcpServerOptions, PrometheusConfig>(
+	PrometheusMcpServerDef,
+	{
+		headerMappings: [{ header: HeaderNames.SERVICE_URL, property: 'url', required: true }],
+
+		resolveConfig(config, headers) {
+			const url = config.url || headers?.get(HeaderNames.SERVICE_URL) || config.headers?.[HeaderNames.SERVICE_URL];
+			if (!url) return null;
+			return { url };
+		},
+	},
+);
+
+registerMcpServerHandler(PrometheusMcpServerHandlerDef);
+
+// backward compatibility
+export { PrometheusMcpServerHandlerDef as PrometheusMcpServerDef };

package/src/providers/prometheus/index.ts

@@ -0,0 +1 @@
+export { PrometheusMcpServerDef, PrometheusMcpServerHandlerDef } from './def';

package/src/providers/relay/def.ts

@@ -0,0 +1,31 @@
+import { RelayMcpServerDef, type CreateRelayMcpServerOptions } from '@wener/ai/mcp/relay';
+import { HeaderNames, type RelayConfig } from '../../server/schema';
+import { defineMcpServerHandler, registerMcpServerHandler } from '../McpServerHandlerDef';
+
+export const RelayMcpServerHandlerDef = defineMcpServerHandler<CreateRelayMcpServerOptions, RelayConfig>(
+	RelayMcpServerDef,
+	{
+		headerMappings: [
+			{ header: HeaderNames.MCP_URL, property: 'url', required: true },
+			{ header: HeaderNames.MCP_TYPE, property: 'transport', default: 'http' },
+		],
+
+		resolveConfig(config, headers) {
+			const url = config.url || headers?.get(HeaderNames.MCP_URL) || config.headers?.[HeaderNames.MCP_URL];
+			const transport =
+				(config.transport as 'http' | 'sse') ||
+				(headers?.get(HeaderNames.MCP_TYPE) as 'http' | 'sse') ||
+				(config.headers?.[HeaderNames.MCP_TYPE] as 'http' | 'sse') ||
+				'http';
+
+			if (!url) return null;
+
+			return { url, transport, headers: config.headers };
+		},
+	},
+);
+
+registerMcpServerHandler(RelayMcpServerHandlerDef);
+
+// backward compatibility
+export { RelayMcpServerHandlerDef as RelayMcpServerDef };

package/src/providers/relay/index.ts

@@ -0,0 +1 @@
+export { RelayMcpServerDef, RelayMcpServerHandlerDef } from './def';

package/src/providers/relay/relay.test.ts

@@ -0,0 +1,47 @@
+import { describe, expect, it } from 'vitest';
+import { createRelayMcpServer } from '@wener/ai/mcp/relay';
+
+describe('createRelayMcpServer', () => {
+	describe('deepwiki relay', () => {
+		it('should connect to deepwiki and list tools', async () => {
+			const { getClient, close } = createRelayMcpServer({
+				url: 'https://mcp.deepwiki.com/mcp',
+				transport: 'http',
+				name: 'deepwiki-relay',
+			});
+
+			try {
+				const client = await getClient();
+				expect(client).toBeDefined();
+
+				const tools = await client.listTools();
+				expect(tools.tools).toBeDefined();
+				expect(Array.isArray(tools.tools)).toBe(true);
+				console.log(
+					'DeepWiki tools:',
+					tools.tools.map((t: { name: string }) => t.name),
+				);
+			} finally {
+				await close();
+			}
+		}, 30000);
+	});
+
+	describe('huggingface relay', () => {
+		it.skip('should connect to huggingface (requires login)', async () => {
+			// Note: huggingface requires login, so this test is skipped by default
+			const { getClient, close } = createRelayMcpServer({
+				url: 'https://huggingface.co/mcp',
+				transport: 'http',
+				name: 'hf-relay',
+			});
+
+			try {
+				const client = await getClient();
+				expect(client).toBeDefined();
+			} finally {
+				await close();
+			}
+		}, 30000);
+	});
+});

package/src/providers/sql/def.ts

@@ -0,0 +1,33 @@
+import { SqlMcpServerDef, type CreateSqlMcpServerOptions } from '@wener/ai/mcp/sql';
+import { HeaderNames, type SqlConfig } from '../../server/schema';
+import { defineMcpServerHandler, registerMcpServerHandler } from '../McpServerHandlerDef';
+
+export const SqlMcpServerHandlerDef = defineMcpServerHandler<CreateSqlMcpServerOptions, SqlConfig>(SqlMcpServerDef, {
+	headerMappings: [
+		{ header: HeaderNames.DB_URL, property: 'url' },
+		{ header: HeaderNames.DB_READ_URL, property: 'readUrl' },
+		{ header: HeaderNames.DB_WRITE_URL, property: 'writeUrl' },
+	],
+
+	resolveConfig(config, headers) {
+		const url =
+			config.dbUrl ||
+			config.dbReadUrl ||
+			config.dbWriteUrl ||
+			headers?.get(HeaderNames.DB_URL) ||
+			headers?.get(HeaderNames.DB_READ_URL) ||
+			headers?.get(HeaderNames.DB_WRITE_URL) ||
+			config.headers?.[HeaderNames.DB_URL] ||
+			config.headers?.[HeaderNames.DB_READ_URL] ||
+			config.headers?.[HeaderNames.DB_WRITE_URL];
+
+		if (!url) return null;
+
+		return { url };
+	},
+});
+
+registerMcpServerHandler(SqlMcpServerHandlerDef);
+
+// backward compatibility
+export { SqlMcpServerHandlerDef as SqlMcpServerDef };