axon-code 2.4.0

package/dist/mcp/lifecycle.js

@@ -0,0 +1,714 @@
+/**
+ * MCP 服务器生命周期管理
+ * 负责 MCP 服务器的启动、停止、监控和重启
+ */
+import { EventEmitter } from 'events';
+import { spawn } from 'child_process';
+// ============ 默认配置 ============
+const DEFAULT_OPTIONS = {
+    startupTimeout: 30000, // 30秒
+    shutdownTimeout: 10000, // 10秒
+    maxRestarts: 3,
+    restartDelay: 1000, // 1秒
+    healthCheckInterval: 30000, // 30秒
+    maxConsecutiveFailures: 5,
+};
+// ============ 生命周期管理器 ============
+export class McpLifecycleManager extends EventEmitter {
+    options;
+    processes;
+    configs;
+    childProcesses;
+    healthCheckTimers;
+    startupTimers;
+    shutdownTimers;
+    dependencies;
+    constructor(options) {
+        super();
+        this.options = { ...DEFAULT_OPTIONS, ...options };
+        this.processes = new Map();
+        this.configs = new Map();
+        this.childProcesses = new Map();
+        this.healthCheckTimers = new Map();
+        this.startupTimers = new Map();
+        this.shutdownTimers = new Map();
+        this.dependencies = new Map();
+    }
+    // ============ 配置管理 ============
+    /**
+     * 注册服务器配置
+     */
+    registerServer(name, config) {
+        this.configs.set(name, config);
+        if (!this.processes.has(name)) {
+            this.processes.set(name, {
+                name,
+                state: 'stopped',
+                restartCount: 0,
+                consecutiveFailures: 0,
+            });
+        }
+    }
+    /**
+     * 注销服务器
+     */
+    async unregisterServer(name) {
+        // 先停止服务器
+        if (this.isRunning(name)) {
+            await this.stop(name, { force: true });
+        }
+        this.configs.delete(name);
+        this.processes.delete(name);
+        this.dependencies.delete(name);
+    }
+    /**
+     * 设置服务器依赖关系
+     */
+    setDependencies(name, dependencies) {
+        this.dependencies.set(name, new Set(dependencies));
+    }
+    // ============ 启动管理 ============
+    /**
+     * 启动服务器
+     */
+    async start(serverName, options) {
+        const process = this.processes.get(serverName);
+        const config = this.configs.get(serverName);
+        if (!process || !config) {
+            throw new Error(`Server not found: ${serverName}`);
+        }
+        // 检查是否已在运行
+        if (process.state === 'running' && !options?.force) {
+            return;
+        }
+        // 检查是否正在启动
+        if (process.state === 'starting') {
+            if (options?.waitForReady) {
+                await this.waitForState(serverName, 'running');
+            }
+            return;
+        }
+        // 启动依赖服务
+        if (options?.dependencies) {
+            await this.startDependencies(serverName, options.dependencies);
+        }
+        // 更新状态
+        this.updateState(serverName, 'starting');
+        this.emit('server:starting', { serverName, process });
+        try {
+            await this.doStart(serverName, config, process);
+        }
+        catch (error) {
+            this.handleStartupFailure(serverName, process, error);
+            throw error;
+        }
+    }
+    /**
+     * 启动所有服务器
+     */
+    async startAll() {
+        const servers = Array.from(this.configs.keys());
+        const errors = [];
+        for (const serverName of servers) {
+            try {
+                await this.start(serverName);
+            }
+            catch (error) {
+                errors.push({ server: serverName, error: error });
+            }
+        }
+        if (errors.length > 0) {
+            const errorMsg = errors.map(e => `${e.server}: ${e.error.message}`).join(', ');
+            throw new Error(`Failed to start some servers: ${errorMsg}`);
+        }
+    }
+    /**
+     * 按依赖关系启动服务器
+     */
+    async startWithDependencies(serverName) {
+        const dependencies = this.dependencies.get(serverName);
+        if (dependencies && dependencies.size > 0) {
+            // 递归启动依赖
+            const depsArray = Array.from(dependencies);
+            for (const dep of depsArray) {
+                if (!this.isRunning(dep)) {
+                    await this.startWithDependencies(dep);
+                }
+            }
+        }
+        await this.start(serverName, { dependencies: dependencies ? Array.from(dependencies) : [] });
+    }
+    /**
+     * 实际启动逻辑
+     */
+    async doStart(serverName, config, process) {
+        if (config.type !== 'stdio' || !config.command) {
+            throw new Error(`Unsupported server type or missing command: ${config.type}`);
+        }
+        // 创建进程
+        const childProcess = spawn(config.command, config.args || [], {
+            env: { ...(globalThis.process?.env || {}), ...config.env },
+            stdio: ['pipe', 'pipe', 'pipe'],
+            windowsHide: true,
+        });
+        this.childProcesses.set(serverName, childProcess);
+        process.pid = childProcess.pid;
+        process.startedAt = new Date();
+        // 设置启动超时
+        const timeoutId = setTimeout(() => {
+            this.handleStartupTimeout(serverName, process);
+        }, this.options.startupTimeout);
+        this.startupTimers.set(serverName, timeoutId);
+        // 监听进程事件
+        this.attachProcessListeners(serverName, childProcess, process);
+        // 等待进程就绪（简单实现：等待一小段时间）
+        await this.waitForReady(serverName, childProcess);
+        // 清除启动超时
+        clearTimeout(timeoutId);
+        this.startupTimers.delete(serverName);
+        // 更新状态
+        this.updateState(serverName, 'running');
+        process.consecutiveFailures = 0;
+        this.emit('server:started', { serverName, process, pid: process.pid });
+        // 开始健康检查
+        this.scheduleHealthCheck(serverName);
+    }
+    /**
+     * 等待服务器就绪
+     */
+    async waitForReady(serverName, childProcess) {
+        return new Promise((resolve, reject) => {
+            let resolved = false;
+            // 简单的就绪检测：等待进程稳定运行一小段时间
+            const readyTimeout = setTimeout(() => {
+                if (!resolved && !childProcess.killed) {
+                    resolved = true;
+                    resolve();
+                }
+            }, 1000);
+            childProcess.once('error', (error) => {
+                if (!resolved) {
+                    resolved = true;
+                    clearTimeout(readyTimeout);
+                    reject(error);
+                }
+            });
+            childProcess.once('exit', (code) => {
+                if (!resolved) {
+                    resolved = true;
+                    clearTimeout(readyTimeout);
+                    reject(new Error(`Process exited with code ${code} during startup`));
+                }
+            });
+        });
+    }
+    /**
+     * 附加进程监听器
+     */
+    attachProcessListeners(serverName, childProcess, process) {
+        childProcess.on('error', (error) => {
+            this.handleProcessError(serverName, process, error);
+        });
+        childProcess.on('exit', (code, signal) => {
+            this.handleProcessExit(serverName, process, code, signal);
+        });
+        // 监听标准输出和错误输出
+        childProcess.stdout?.on('data', (data) => {
+            this.emit('server:stdout', { serverName, data: data.toString() });
+        });
+        childProcess.stderr?.on('data', (data) => {
+            this.emit('server:stderr', { serverName, data: data.toString() });
+        });
+    }
+    /**
+     * 启动依赖服务
+     */
+    async startDependencies(_serverName, dependencies) {
+        for (const dep of dependencies) {
+            if (!this.isRunning(dep)) {
+                await this.start(dep, { waitForReady: true });
+            }
+        }
+    }
+    // ============ 停止管理 ============
+    /**
+     * 停止服务器
+     */
+    async stop(serverName, options) {
+        const process = this.processes.get(serverName);
+        const childProcess = this.childProcesses.get(serverName);
+        if (!process) {
+            throw new Error(`Server not found: ${serverName}`);
+        }
+        if (process.state === 'stopped') {
+            return;
+        }
+        // 停止健康检查
+        this.cancelHealthCheck(serverName);
+        // 更新状态
+        this.updateState(serverName, 'stopping');
+        this.emit('server:stopping', { serverName, process, reason: options?.reason });
+        try {
+            if (childProcess && !childProcess.killed) {
+                await this.doStop(serverName, childProcess, options);
+            }
+            this.updateState(serverName, 'stopped');
+            process.stoppedAt = new Date();
+            process.pid = undefined;
+            this.emit('server:stopped', { serverName, process });
+        }
+        catch (error) {
+            this.updateState(serverName, 'error');
+            process.lastError = error;
+            this.emit('server:error', { serverName, process, error });
+            throw error;
+        }
+        finally {
+            this.childProcesses.delete(serverName);
+        }
+    }
+    /**
+     * 停止所有服务器
+     */
+    async stopAll(force) {
+        const servers = Array.from(this.processes.entries())
+            .filter(([, proc]) => proc.state === 'running' || proc.state === 'starting')
+            .map(([name]) => name);
+        const errors = [];
+        for (const serverName of servers) {
+            try {
+                await this.stop(serverName, { force });
+            }
+            catch (error) {
+                errors.push({ server: serverName, error: error });
+            }
+        }
+        if (errors.length > 0 && !force) {
+            const errorMsg = errors.map(e => `${e.server}: ${e.error.message}`).join(', ');
+            throw new Error(`Failed to stop some servers: ${errorMsg}`);
+        }
+    }
+    /**
+     * 实际停止逻辑
+     */
+    async doStop(serverName, childProcess, options) {
+        return new Promise((resolve, reject) => {
+            const signal = options?.killSignal || 'SIGTERM';
+            let killed = false;
+            // 设置停止超时
+            const timeoutId = setTimeout(() => {
+                if (!killed && !childProcess.killed) {
+                    // 超时后强制杀死进程
+                    childProcess.kill('SIGKILL');
+                    killed = true;
+                }
+            }, this.options.shutdownTimeout);
+            this.shutdownTimers.set(serverName, timeoutId);
+            childProcess.once('exit', () => {
+                clearTimeout(timeoutId);
+                this.shutdownTimers.delete(serverName);
+                resolve();
+            });
+            // 发送停止信号
+            try {
+                if (options?.force) {
+                    childProcess.kill('SIGKILL');
+                }
+                else {
+                    childProcess.kill(signal);
+                }
+            }
+            catch (error) {
+                clearTimeout(timeoutId);
+                this.shutdownTimers.delete(serverName);
+                reject(error);
+            }
+        });
+    }
+    // ============ 重启管理 ============
+    /**
+     * 重启服务器
+     */
+    async restart(serverName) {
+        const process = this.processes.get(serverName);
+        if (!process) {
+            throw new Error(`Server not found: ${serverName}`);
+        }
+        this.emit('server:restarting', { serverName, process });
+        // 停止服务器
+        if (this.isRunning(serverName) || process.state === 'starting') {
+            await this.stop(serverName);
+        }
+        // 增加重启计数
+        process.restartCount++;
+        // 计算退避延迟
+        const delay = this.calculateBackoffDelay(process.restartCount);
+        if (delay > 0) {
+            await this.sleep(delay);
+        }
+        // 启动服务器
+        await this.start(serverName);
+    }
+    /**
+     * 重启所有服务器
+     */
+    async restartAll() {
+        const servers = Array.from(this.configs.keys());
+        for (const serverName of servers) {
+            try {
+                await this.restart(serverName);
+            }
+            catch (error) {
+                this.emit('server:error', {
+                    serverName,
+                    process: this.processes.get(serverName),
+                    error
+                });
+            }
+        }
+    }
+    /**
+     * 自动重启（内部使用）
+     */
+    async autoRestart(serverName, process) {
+        // 检查是否应该重启
+        if (!this.shouldAutoRestart(process)) {
+            this.updateState(serverName, 'stopped');
+            this.emit('server:crashed', { serverName, process, reason: 'max_restarts_exceeded' });
+            return;
+        }
+        try {
+            await this.restart(serverName);
+        }
+        catch (error) {
+            process.lastError = error;
+            process.consecutiveFailures++;
+            this.emit('server:error', { serverName, process, error });
+        }
+    }
+    /**
+     * 计算退避延迟
+     */
+    calculateBackoffDelay(restartCount) {
+        // 指数退避：delay * 2^(n-1)
+        const maxDelay = 60000; // 最大 60 秒
+        const delay = this.options.restartDelay * Math.pow(2, Math.min(restartCount - 1, 6));
+        return Math.min(delay, maxDelay);
+    }
+    /**
+     * 判断是否应该自动重启
+     */
+    shouldAutoRestart(process) {
+        return (process.restartCount < this.options.maxRestarts &&
+            process.consecutiveFailures < this.options.maxConsecutiveFailures);
+    }
+    // ============ 健康检查 ============
+    /**
+     * 执行健康检查
+     */
+    async healthCheck(serverName) {
+        const process = this.processes.get(serverName);
+        const childProcess = this.childProcesses.get(serverName);
+        const result = {
+            healthy: false,
+            lastCheck: new Date(),
+        };
+        if (!process) {
+            result.error = 'Server not found';
+            return result;
+        }
+        if (process.state !== 'running') {
+            result.error = `Server is ${process.state}`;
+            return result;
+        }
+        if (!childProcess || childProcess.killed) {
+            result.error = 'Process not found or killed';
+            return result;
+        }
+        try {
+            // 简单的健康检查：进程是否存活
+            const startTime = Date.now();
+            const alive = !childProcess.killed && childProcess.pid !== undefined;
+            const latency = Date.now() - startTime;
+            result.healthy = alive;
+            result.latency = latency;
+            result.details = {
+                pid: childProcess.pid,
+                uptime: process.startedAt ? Date.now() - process.startedAt.getTime() : 0,
+                restartCount: process.restartCount,
+            };
+            if (result.healthy) {
+                this.emit('health:ok', { serverName, result });
+            }
+            else {
+                this.emit('health:failed', { serverName, result });
+            }
+        }
+        catch (error) {
+            result.error = error.message;
+            this.emit('health:failed', { serverName, result, error });
+        }
+        return result;
+    }
+    /**
+     * 检查所有服务器健康状态
+     */
+    async healthCheckAll() {
+        const results = new Map();
+        const serverNames = Array.from(this.processes.keys());
+        for (const serverName of serverNames) {
+            const result = await this.healthCheck(serverName);
+            results.set(serverName, result);
+        }
+        return results;
+    }
+    /**
+     * 调度健康检查
+     */
+    scheduleHealthCheck(serverName) {
+        // 取消现有的健康检查
+        this.cancelHealthCheck(serverName);
+        // 调度新的健康检查
+        const timerId = setInterval(async () => {
+            const result = await this.healthCheck(serverName);
+            if (!result.healthy) {
+                const process = this.processes.get(serverName);
+                if (process) {
+                    process.consecutiveFailures++;
+                    // 如果连续失败次数过多，尝试重启
+                    if (process.consecutiveFailures >= 3) {
+                        this.emit('health:degraded', { serverName, result });
+                        await this.autoRestart(serverName, process);
+                    }
+                }
+            }
+            else {
+                const process = this.processes.get(serverName);
+                if (process) {
+                    process.consecutiveFailures = 0;
+                }
+            }
+        }, this.options.healthCheckInterval);
+        this.healthCheckTimers.set(serverName, timerId);
+    }
+    /**
+     * 取消健康检查
+     */
+    cancelHealthCheck(serverName) {
+        const timerId = this.healthCheckTimers.get(serverName);
+        if (timerId) {
+            clearInterval(timerId);
+            this.healthCheckTimers.delete(serverName);
+        }
+    }
+    // ============ 状态查询 ============
+    /**
+     * 获取服务器状态
+     */
+    getState(serverName) {
+        const process = this.processes.get(serverName);
+        return process?.state || 'stopped';
+    }
+    /**
+     * 获取进程信息
+     */
+    getProcess(serverName) {
+        return this.processes.get(serverName) || null;
+    }
+    /**
+     * 获取所有进程信息
+     */
+    getAllProcesses() {
+        return Array.from(this.processes.values());
+    }
+    /**
+     * 检查服务器是否运行中
+     */
+    isRunning(serverName) {
+        const process = this.processes.get(serverName);
+        return process?.state === 'running';
+    }
+    /**
+     * 获取运行中的服务器列表
+     */
+    getRunningServers() {
+        const entries = Array.from(this.processes.entries());
+        return entries
+            .filter(([, proc]) => proc.state === 'running')
+            .map(([name]) => name);
+    }
+    /**
+     * 获取服务器统计信息
+     */
+    getStats(serverName) {
+        const process = this.processes.get(serverName);
+        if (!process) {
+            return null;
+        }
+        return {
+            uptime: process.startedAt ? Date.now() - process.startedAt.getTime() : undefined,
+            restartCount: process.restartCount,
+            consecutiveFailures: process.consecutiveFailures,
+            lastError: process.lastError?.message,
+        };
+    }
+    // ============ 配置更新 ============
+    /**
+     * 更新服务器配置（需要重启才能生效）
+     */
+    async onConfigChange(serverName, newConfig) {
+        const wasRunning = this.isRunning(serverName);
+        // 停止服务器
+        if (wasRunning) {
+            await this.stop(serverName);
+        }
+        // 更新配置
+        this.configs.set(serverName, newConfig);
+        this.emit('config:changed', { serverName, config: newConfig });
+        // 如果之前在运行，重新启动
+        if (wasRunning) {
+            await this.start(serverName);
+        }
+    }
+    // ============ 清理和销毁 ============
+    /**
+     * 清理所有资源
+     */
+    async cleanup() {
+        // 停止所有健康检查
+        const healthCheckTimers = Array.from(this.healthCheckTimers.values());
+        for (const timerId of healthCheckTimers) {
+            clearInterval(timerId);
+        }
+        this.healthCheckTimers.clear();
+        // 清除所有定时器
+        const startupTimers = Array.from(this.startupTimers.values());
+        for (const timerId of startupTimers) {
+            clearTimeout(timerId);
+        }
+        this.startupTimers.clear();
+        const shutdownTimers = Array.from(this.shutdownTimers.values());
+        for (const timerId of shutdownTimers) {
+            clearTimeout(timerId);
+        }
+        this.shutdownTimers.clear();
+        // 停止所有服务器
+        await this.stopAll(true);
+        // 清空数据
+        this.processes.clear();
+        this.configs.clear();
+        this.childProcesses.clear();
+        this.dependencies.clear();
+        // 移除所有监听器
+        this.removeAllListeners();
+    }
+    // ============ 私有辅助方法 ============
+    /**
+     * 更新服务器状态
+     */
+    updateState(serverName, state) {
+        const process = this.processes.get(serverName);
+        if (process) {
+            process.state = state;
+        }
+    }
+    /**
+     * 处理进程错误
+     */
+    handleProcessError(serverName, process, error) {
+        process.lastError = error;
+        process.consecutiveFailures++;
+        this.updateState(serverName, 'error');
+        this.emit('server:error', { serverName, process, error });
+    }
+    /**
+     * 处理进程退出
+     */
+    handleProcessExit(serverName, process, code, signal) {
+        this.childProcesses.delete(serverName);
+        this.cancelHealthCheck(serverName);
+        // 如果是正常停止，不做处理
+        if (process.state === 'stopping') {
+            return;
+        }
+        // 异常退出
+        if (code !== 0 && code !== null) {
+            process.lastError = new Error(`Process exited with code ${code}`);
+            process.consecutiveFailures++;
+            this.updateState(serverName, 'crashed');
+            this.emit('server:crashed', { serverName, process, code, signal });
+            // 尝试自动重启
+            this.autoRestart(serverName, process).catch((error) => {
+                this.emit('server:error', { serverName, process, error });
+            });
+        }
+        else {
+            this.updateState(serverName, 'stopped');
+            this.emit('server:stopped', { serverName, process, code, signal });
+        }
+    }
+    /**
+     * 处理启动超时
+     */
+    handleStartupTimeout(serverName, process) {
+        const childProcess = this.childProcesses.get(serverName);
+        if (childProcess && !childProcess.killed) {
+            childProcess.kill('SIGKILL');
+        }
+        process.lastError = new Error('Startup timeout exceeded');
+        this.updateState(serverName, 'error');
+        this.emit('server:error', {
+            serverName,
+            process,
+            error: process.lastError
+        });
+    }
+    /**
+     * 处理启动失败
+     */
+    handleStartupFailure(serverName, process, error) {
+        process.lastError = error;
+        process.consecutiveFailures++;
+        this.updateState(serverName, 'error');
+        // 清理进程
+        const childProcess = this.childProcesses.get(serverName);
+        if (childProcess && !childProcess.killed) {
+            childProcess.kill('SIGKILL');
+        }
+        this.childProcesses.delete(serverName);
+        // 清除启动超时
+        const timerId = this.startupTimers.get(serverName);
+        if (timerId) {
+            clearTimeout(timerId);
+            this.startupTimers.delete(serverName);
+        }
+    }
+    /**
+     * 等待服务器达到指定状态
+     */
+    async waitForState(serverName, targetState, timeout = 30000) {
+        const startTime = Date.now();
+        return new Promise((resolve, reject) => {
+            const checkState = () => {
+                const currentState = this.getState(serverName);
+                if (currentState === targetState) {
+                    resolve();
+                }
+                else if (Date.now() - startTime > timeout) {
+                    reject(new Error(`Timeout waiting for state ${targetState}`));
+                }
+                else {
+                    setTimeout(checkState, 100);
+                }
+            };
+            checkState();
+        });
+    }
+    /**
+     * 休眠
+     */
+    sleep(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+}
+//# sourceMappingURL=lifecycle.js.map