route-claudecode
Version:
Advanced routing and transformation system for Claude Code outputs to multiple AI providers
296 lines • 11.6 kB
JavaScript
"use strict";
/**
* Modular Router Server
*
* 按照细菌式编程原则重构的服务器主入口
* - 小巧：每个模块不超过500行
* - 模块化：功能组织成可插拔的独立单元
* - 自包含：每个模块都可以独立使用和测试
*/
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.ModularRouterServer = void 0;
exports.createModularRouterServer = createModularRouterServer;
const fastify_1 = __importDefault(require("fastify"));
const unified_processor_1 = require("@/input/unified-processor");
const routing_1 = require("@/routing");
const anthropic_1 = require("@/output/anthropic");
const logging_1 = require("@/logging");
const provider_expander_1 = require("@/routing/provider-expander");
// Patch system removed - now using unified compatibility preprocessor
// // import { ResponsePipeline } from '@/pipeline/response-pipeline';
const manager_1 = require("@/transformers/manager");
const unified_patch_preprocessor_1 = require("@/preprocessing/unified-patch-preprocessor");
// 导入模块化组件
const provider_manager_1 = require("./core/provider-manager");
const health_handler_1 = require("./handlers/health-handler");
const admin_handler_1 = require("./handlers/admin-handler");
const messages_handler_1 = require("./handlers/messages-handler");
const streaming_handler_1 = require("./handlers/streaming-handler");
const route_setup_1 = require("./core/route-setup");
/**
* 模块化路由服务器
*
* 采用依赖注入和组合模式，将复杂的服务器逻辑分解为小的、
* 可测试的模块
*/
class ModularRouterServer {
fastify;
config;
// 核心组件
logger;
requestTracker;
errorTracker;
// 业务组件
inputProcessor;
routingEngine;
outputProcessor;
// private patchManager: removed - using unified compatibility preprocessor
// // private responsePipeline!: ResponsePipeline;
unifiedPreprocessor;
// 模块化组件
providerManager;
healthHandler;
adminHandler;
messagesHandler;
streamingHandler;
routeSetup;
constructor(config, serverType = 'modular') {
this.config = config;
this.fastify = (0, fastify_1.default)({
logger: false,
bodyLimit: 10 * 1024 * 1024 // 10MB
});
this.initializeCore();
this.initializeBusinessComponents();
this.initializeModularComponents();
this.logger.info('Modular Router Server initialized', {
type: serverType,
port: config.server.port,
providers: Object.keys(config.providers || {}).length
});
}
/**
* 初始化核心组件
*/
initializeCore() {
// 设置日志系统
(0, logging_1.setDefaultPort)(this.config.server.port);
this.logger = (0, logging_1.getLogger)(this.config.server.port);
this.requestTracker = (0, logging_1.createRequestTracker)(this.config.server.port);
this.errorTracker = (0, logging_1.createErrorTracker)(this.config.server.port);
this.logger.info('Core components initialized');
}
/**
* 初始化业务组件
*/
initializeBusinessComponents() {
// 输入/输出处理器
this.inputProcessor = new unified_processor_1.UnifiedInputProcessor();
this.outputProcessor = new anthropic_1.AnthropicOutputProcessor(this.config.server.port);
// 路由引擎
this.routingEngine = new routing_1.RoutingEngine(this.config.routing || {});
// 补丁和流水线系统 (补丁系统已移除)
// this.patchManager = removed - using unified compatibility preprocessor
// // this.responsePipeline = new ResponsePipeline(removed, transformationManager, this.config.server.port);
this.unifiedPreprocessor = (0, unified_patch_preprocessor_1.getUnifiedPatchPreprocessor)(this.config.server.port);
// 初始化变换管理器
if ('initialize' in manager_1.transformationManager && typeof manager_1.transformationManager.initialize === 'function') {
manager_1.transformationManager.initialize(this.config.server.port);
}
this.logger.info('Business components initialized');
}
/**
* 初始化模块化组件
*/
initializeModularComponents() {
// Provider管理器
this.providerManager = (0, provider_manager_1.createProviderManager)({
config: this.config,
logger: this.logger
});
this.providerManager.initializeProviders();
// 处理器模块
this.healthHandler = (0, health_handler_1.createHealthHandler)({
providers: this.providerManager.getAllProviders(),
logger: this.logger,
errorTracker: this.errorTracker,
requestTracker: this.requestTracker
});
this.adminHandler = (0, admin_handler_1.createAdminHandler)({
providers: this.providerManager.getAllProviders(),
logger: this.logger,
errorTracker: this.errorTracker,
requestTracker: this.requestTracker,
config: this.config
});
this.streamingHandler = (0, streaming_handler_1.createStreamingHandler)({
logger: this.logger,
// responsePipeline: this.responsePipeline,
unifiedPreprocessor: this.unifiedPreprocessor,
config: this.config
});
this.messagesHandler = (0, messages_handler_1.createMessagesHandler)({
inputProcessor: this.inputProcessor,
routingEngine: this.routingEngine,
outputProcessor: this.outputProcessor,
streamingHandler: this.streamingHandler,
providers: this.providerManager.getAllProviders(),
logger: this.logger,
config: this.config
});
// 路由设置
this.routeSetup = (0, route_setup_1.createRouteSetup)({
fastify: this.fastify,
healthHandler: this.healthHandler,
adminHandler: this.adminHandler,
messagesHandler: this.messagesHandler,
logger: this.logger,
config: this.config
});
this.logger.info('Modular components initialized');
}
/**
* 设置路由和中间件
*/
setup() {
// 设置路由
this.routeSetup.setupRoutes();
// 设置钩子
this.routeSetup.setupHooks();
// 处理Provider扩展
this.handleProviderExpansion();
this.logger.info('Server setup completed');
}
/**
* 处理Provider扩展
*/
async handleProviderExpansion() {
try {
if (this.config.providers && Object.keys(this.config.providers).length > 0) {
this.logger.info('Processing provider expansion...');
const expansion = provider_expander_1.ProviderExpander.expandProviders(this.config.providers);
this.logger.info('Provider expansion completed', {
originalCount: Object.keys(this.config.providers).length,
expandedCount: expansion.expandedProviders.size,
originalProviders: expansion.originalProviders.size
});
}
}
catch (error) {
this.logger.warn('Provider expansion failed, continuing with original config', {
error: error instanceof Error ? error.message : String(error)
});
}
}
/**
* 启动服务器
*/
async start() {
try {
this.setup();
await this.fastify.listen({
port: this.config.server.port,
host: this.config.server.host || '0.0.0.0'
});
const healthyProviders = await this.providerManager.getHealthyProviders();
console.log('\n🚀 Modular Router Server Started');
console.log('================================');
console.log(`📡 Server URL: http://${this.config.server.host || 'localhost'}:${this.config.server.port}`);
console.log(`🔧 Total Providers: ${this.providerManager.getProviderCount()}`);
console.log(`✅ Healthy Providers: ${healthyProviders.length}`);
console.log(`📋 Available Endpoints:`);
console.log(` • Health: GET /health`);
console.log(` • Status: GET /status`);
console.log(` • Messages: POST /v1/messages`);
console.log(` • OpenAI Compat: POST /v1/chat/completions`);
console.log(` • Admin: GET /api/stats`);
this.logger.info('Modular Router Server started successfully', {
port: this.config.server.port,
host: this.config.server.host,
totalProviders: this.providerManager.getProviderCount(),
healthyProviders: healthyProviders.length,
providers: healthyProviders
});
}
catch (error) {
this.logger.error('Failed to start server', {
error: error instanceof Error ? error.message : String(error),
port: this.config.server.port
});
throw error;
}
}
/**
* 停止服务器
*/
async stop() {
try {
this.logger.info('Shutting down Modular Router Server...');
// 关闭Provider
await this.providerManager.shutdown();
// 清理会话管理器（没有shutdown方法）
// sessionManager is a singleton and will persist
// 关闭服务器
await this.fastify.close();
console.log('\n📴 Modular Router Server Stopped');
this.logger.info('Modular Router Server stopped successfully');
}
catch (error) {
this.logger.error('Error during server shutdown', {
error: error instanceof Error ? error.message : String(error)
});
throw error;
}
}
/**
* 获取服务器统计信息
*/
async getStats() {
const healthyProviders = await this.providerManager.getHealthyProviders();
const providerStats = await this.providerManager.getProviderStats();
return {
timestamp: new Date().toISOString(),
server: {
port: this.config.server.port,
uptime: process.uptime(),
memory: process.memoryUsage()
},
providers: {
total: this.providerManager.getProviderCount(),
healthy: healthyProviders.length,
stats: providerStats
},
system: {
nodeVersion: process.version,
platform: process.platform
}
};
}
/**
* 获取Provider管理器（用于测试）
*/
getProviderManager() {
return this.providerManager;
}
/**
* 获取Fastify实例（用于测试）
*/
getFastify() {
return this.fastify;
}
}
exports.ModularRouterServer = ModularRouterServer;
/**
* 创建模块化服务器实例的工厂函数
*/
function createModularRouterServer(config, serverType) {
return new ModularRouterServer(config, serverType);
}
/**
* 默认导出
*/
exports.default = ModularRouterServer;
//# sourceMappingURL=modular-server.js.map