hyacinth-ai 0.9.6

package/dist/mcp/client.js

@@ -0,0 +1,161 @@
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+import { SSEClientTransport } from '@modelcontextprotocol/sdk/client/sse.js';
+import { createLogger } from '../logging/logger.js';
+function withTimeout(promise, ms, errorMsg) {
+    let timer;
+    return Promise.race([
+        promise,
+        new Promise((_, reject) => {
+            timer = setTimeout(() => reject(new Error(errorMsg)), ms);
+        }),
+    ]).finally(() => clearTimeout(timer));
+}
+/**
+ * MCPClient — 连接 MCP Server，获取工具列表，执行工具调用
+ *
+ * 支持 stdio 传输（子进程）和 HTTP SSE 传输
+ */
+export class MCPClient {
+    config;
+    client = null;
+    transport = null;
+    connected = false;
+    tools = [];
+    logger;
+    constructor(config) {
+        this.config = config;
+        this.logger = createLogger(`mcp:client:${config.name}`);
+    }
+    /** 连接到 MCP Server */
+    async connect(externalTransport) {
+        try {
+            if (externalTransport) {
+                this.transport = externalTransport;
+            }
+            else if (this.config.command) {
+                // stdio 传输
+                this.transport = new StdioClientTransport({
+                    command: this.config.command,
+                    args: this.config.args,
+                    env: this.config.env
+                        ? { ...this.config.env }
+                        : {},
+                });
+            }
+            else if (this.config.url) {
+                // HTTP SSE 传输
+                const requestInit = {};
+                if (this.config.headers) {
+                    requestInit.headers = this.config.headers;
+                }
+                this.transport = new SSEClientTransport(new URL(this.config.url), { requestInit });
+            }
+            else {
+                this.logger.warn('no command or url configured, skipping');
+                return;
+            }
+            if (!this.transport) {
+                this.logger.warn('transport is not initialized, skipping');
+                return;
+            }
+            this.client = new Client({
+                name: `agent-mcp-${this.config.name}`,
+                version: '1.0.0',
+            }, {
+                capabilities: {},
+            });
+            await withTimeout(this.client.connect(this.transport), this.config.connectTimeout ?? 30_000, 'MCP connect timed out (30s)');
+            // 获取工具列表
+            const result = await this.client.listTools();
+            this.tools = (result.tools ?? []).map((tool) => ({
+                name: tool.name,
+                description: tool.description,
+                inputSchema: tool.inputSchema,
+            }));
+            this.connected = true;
+            this.logger.info('connected', { tools: this.tools.length });
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            this.logger.warn('connection failed', { error: msg });
+            this.connected = false;
+            // 必须向上抛出，否则 MCPServerManager 会误认为连接成功
+            throw error;
+        }
+    }
+    /** 断开连接 */
+    async disconnect() {
+        if (this.transport) {
+            try {
+                await this.transport.close();
+            }
+            catch {
+                // SSE transport 可能抛出错误，忽略
+            }
+            this.transport = null;
+        }
+        this.client = null;
+        this.connected = false;
+        this.tools = [];
+    }
+    /** 是否已连接 */
+    isConnected() {
+        return this.connected;
+    }
+    /** 获取 MCP Server 提供的工具列表 */
+    getTools() {
+        return this.tools;
+    }
+    /** 获取工具索引（名称+描述列表） */
+    getToolIndex() {
+        if (this.tools.length === 0)
+            return '';
+        return (`MCP Server [${this.config.name}]:\n` +
+            this.tools
+                .map((t) => `- ${t.name}: ${t.description ?? '(no description)'}`)
+                .join('\n'));
+    }
+    /** 调用 MCP 工具 */
+    async callTool(name, args) {
+        if (!this.client || !this.connected) {
+            return `Error: MCP Server "${this.config.name}" is not connected`;
+        }
+        try {
+            const result = await withTimeout(this.client.callTool({ name, arguments: args }), this.config.callTimeout ?? 60_000, `MCP tool call timed out (60s): ${name}`);
+            // 将结果转换为字符串
+            if (typeof result.content === 'string') {
+                return result.content;
+            }
+            if (Array.isArray(result.content)) {
+                return result.content
+                    .map((block) => {
+                    if (block.type === 'text' && block.text)
+                        return block.text;
+                    return JSON.stringify(block);
+                })
+                    .join('\n');
+            }
+            return JSON.stringify(result.content);
+        }
+        catch (error) {
+            if (error instanceof Error && error.message.includes('timed out')) {
+                return error.message;
+            }
+            const msg = error instanceof Error ? error.message : String(error);
+            const lowerMsg = msg.toLowerCase();
+            if (lowerMsg.includes('not connected') || lowerMsg.includes('connection') || lowerMsg.includes('closed')) {
+                return `MCP Server '${this.config.name}' connection lost. The server may have crashed.`;
+            }
+            if (lowerMsg.includes('invalid') || lowerMsg.includes('schema') || lowerMsg.includes('parameter')) {
+                return `MCP tool '${name}' parameter error: ${msg}`;
+            }
+            return `MCP tool '${name}' internal error: ${msg}`;
+        }
+    }
+    /** 获取 Server 名称 */
+    getName() {
+        return this.config.name;
+    }
+}
+//# sourceMappingURL=client.js.map

package/dist/mcp/config.d.ts

@@ -0,0 +1,15 @@
+import type { MCPConfig } from '../types.js';
+/**
+ * MCPConfigLoader — 从配置文件加载 MCP Server 配置
+ *
+ * 查找顺序：
+ * 1. ~/.agent/mcp.json（用户级全局配置）
+ * 2. <cwd>/.mcp.json（项目级配置）
+ */
+export declare class MCPConfigLoader {
+    /** 从配置目录加载 MCP 配置 */
+    load(projectDir: string): Promise<MCPConfig[]>;
+    /** 解析 mcpServers 配置对象 */
+    private parseConfig;
+}
+//# sourceMappingURL=config.d.ts.map

package/dist/mcp/config.js

@@ -0,0 +1,85 @@
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { createLogger } from '../logging/logger.js';
+const logger = createLogger('mcp:config');
+/** 危险命令黑名单：这些命令可用于执行任意代码 */
+const BLOCKED_COMMANDS = new Set([
+    'cmd.exe', 'cmd',
+    'powershell', 'pwsh',
+    'bash', 'sh', 'zsh', 'fish',
+    'wscript', 'cscript',
+]);
+/**
+ * MCPConfigLoader — 从配置文件加载 MCP Server 配置
+ *
+ * 查找顺序：
+ * 1. ~/.agent/mcp.json（用户级全局配置）
+ * 2. <cwd>/.mcp.json（项目级配置）
+ */
+export class MCPConfigLoader {
+    /** 从配置目录加载 MCP 配置 */
+    async load(projectDir) {
+        // 用户级全局配置优先
+        const userConfigPath = path.join(os.homedir(), '.agent', 'mcp.json');
+        try {
+            const content = await fs.readFile(userConfigPath, 'utf-8');
+            const config = JSON.parse(content);
+            if (config.mcpServers && typeof config.mcpServers === 'object') {
+                return this.parseConfig(config.mcpServers);
+            }
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            logger.warn(`failed to load MCP config from ~/.agent/mcp.json: ${msg}`);
+        }
+        // 项目级 .mcp.json 作为补充
+        try {
+            const projectPath = path.join(projectDir, '.mcp.json');
+            const content = await fs.readFile(projectPath, 'utf-8');
+            const config = JSON.parse(content);
+            if (config.mcpServers && typeof config.mcpServers === 'object') {
+                return this.parseConfig(config.mcpServers);
+            }
+        }
+        catch (err) {
+            // 项目级配置不存在是正常的，不打印警告
+        }
+        return [];
+    }
+    /** 解析 mcpServers 配置对象 */
+    parseConfig(mcpServers) {
+        const configs = [];
+        for (const [name, serverConfig] of Object.entries(mcpServers)) {
+            if (typeof serverConfig !== 'object' || serverConfig === null)
+                continue;
+            const cfg = serverConfig;
+            if (cfg._disabled)
+                continue;
+            // 校验 command：拒绝危险命令
+            const command = cfg.command;
+            if (command) {
+                const baseName = command.split(/[/\\]/).pop()?.toLowerCase() ?? command.toLowerCase();
+                if (BLOCKED_COMMANDS.has(baseName)) {
+                    logger.error(`MCP Server "${name}" blocked: command "${command}" is not allowed (dangerous shell command)`);
+                    continue;
+                }
+            }
+            configs.push({
+                name,
+                command,
+                args: cfg.args,
+                url: cfg.url,
+                env: cfg.env,
+                headers: cfg.headers,
+                packageType: cfg.packageType,
+                package: cfg.package,
+                packageVersion: cfg.packageVersion,
+                connectTimeout: cfg.connectTimeout,
+                callTimeout: cfg.callTimeout,
+            });
+        }
+        return configs;
+    }
+}
+//# sourceMappingURL=config.js.map

package/dist/mcp/index.d.ts

@@ -0,0 +1,7 @@
+export { MCPClient, type MCPToolInfo } from './client.js';
+export { MCPBridge } from './bridge.js';
+export { MCPConfigLoader } from './config.js';
+export { MCPServerManager } from './lifecycle.js';
+export { MCPInstallManager } from './install-manager.js';
+export { MCPSystem, type MCPSystemDeps } from './system.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/mcp/index.js

@@ -0,0 +1,7 @@
+export { MCPClient } from './client.js';
+export { MCPBridge } from './bridge.js';
+export { MCPConfigLoader } from './config.js';
+export { MCPServerManager } from './lifecycle.js';
+export { MCPInstallManager } from './install-manager.js';
+export { MCPSystem } from './system.js';
+//# sourceMappingURL=index.js.map

package/dist/mcp/install-manager.d.ts

@@ -0,0 +1,31 @@
+import type { MCPConfig } from '../types.js';
+/**
+ * MCPInstallManager — 统一管理 MCP Server 的下载、版本检测和安全升级。
+ *
+ * 安装目录：~/.agent/mcp-servers/{name}/
+ * 版本索引：~/.agent/mcp-installed.json
+ *
+ * 安全升级：新版本先下载到 {name}.new/，成功后再替换 {name}/，失败则保留旧版。
+ */
+export declare class MCPInstallManager {
+    private installed;
+    private indexFilePath;
+    private baseDir;
+    constructor();
+    /**
+     * 确保 MCP Server 已安装。返回解析后的 command 和 args。
+     * 若不需要安装（本地命令或 SSE），直接返回原 command/args。
+     */
+    ensureInstalled(config: MCPConfig): Promise<{
+        command: string;
+        args?: string[];
+    } | null>;
+    private install;
+    private installNpm;
+    private installPython;
+    private getEntryCommand;
+    private verifyLocal;
+    private loadIndex;
+    private saveIndex;
+}
+//# sourceMappingURL=install-manager.d.ts.map

package/dist/mcp/install-manager.js

@@ -0,0 +1,158 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { execSync } from 'node:child_process';
+import { createLogger } from '../logging/logger.js';
+const logger = createLogger('mcp:install');
+/**
+ * MCPInstallManager — 统一管理 MCP Server 的下载、版本检测和安全升级。
+ *
+ * 安装目录：~/.agent/mcp-servers/{name}/
+ * 版本索引：~/.agent/mcp-installed.json
+ *
+ * 安全升级：新版本先下载到 {name}.new/，成功后再替换 {name}/，失败则保留旧版。
+ */
+export class MCPInstallManager {
+    installed;
+    indexFilePath;
+    baseDir;
+    constructor() {
+        this.baseDir = path.join(os.homedir(), '.agent', 'mcp-servers');
+        this.indexFilePath = path.join(os.homedir(), '.agent', 'mcp-installed.json');
+        this.installed = this.loadIndex();
+    }
+    /**
+     * 确保 MCP Server 已安装。返回解析后的 command 和 args。
+     * 若不需要安装（本地命令或 SSE），直接返回原 command/args。
+     */
+    async ensureInstalled(config) {
+        if (!config.packageType) {
+            return this.verifyLocal(config);
+        }
+        const targetVersion = config.packageVersion || 'latest';
+        const entry = this.installed.servers[config.name];
+        if (entry && entry.version === targetVersion) {
+            logger.info(`MCP "${config.name}" already installed (${targetVersion}), skipping`);
+            return this.getEntryCommand(config.name);
+        }
+        return this.install(config, targetVersion);
+    }
+    // ── 内部方法 ──
+    async install(config, version) {
+        const name = config.name;
+        const serverDir = path.join(this.baseDir, name);
+        const tempDir = path.join(this.baseDir, `${name}.new`);
+        logger.info(`Installing MCP "${name}" (${config.packageType}:${config.package}@${version})`);
+        try {
+            // 清理上次失败的临时目录
+            if (fs.existsSync(tempDir)) {
+                fs.rmSync(tempDir, { recursive: true, force: true });
+            }
+            fs.mkdirSync(tempDir, { recursive: true });
+            if (config.packageType === 'npm') {
+                this.installNpm(config.package, version, tempDir);
+            }
+            else if (config.packageType === 'python') {
+                this.installPython(config.package, version, tempDir);
+            }
+            else {
+                logger.warn(`Unknown packageType: ${config.packageType}`);
+                return null;
+            }
+            // 原子替换
+            if (fs.existsSync(serverDir)) {
+                fs.rmSync(serverDir, { recursive: true, force: true });
+            }
+            fs.renameSync(tempDir, serverDir);
+            const entry = { name, packageType: config.packageType, package: config.package, version, installPath: serverDir };
+            this.installed.servers[name] = entry;
+            this.saveIndex();
+            logger.info(`MCP "${name}" installed (${version})`);
+            return this.getEntryCommand(name);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            logger.warn(`Install failed for "${name}": ${msg}, keeping previous version`);
+            try {
+                if (fs.existsSync(tempDir))
+                    fs.rmSync(tempDir, { recursive: true, force: true });
+            }
+            catch { /* 清理失败不阻塞 */ }
+            const oldEntry = this.installed.servers[name];
+            if (oldEntry) {
+                logger.info(`Using cached version of "${name}" (${oldEntry.version})`);
+                return this.getEntryCommand(name);
+            }
+            return null;
+        }
+    }
+    installNpm(packageName, version, dir) {
+        const pkgSpec = version === 'latest' ? packageName : `${packageName}@${version}`;
+        execSync('npm init -y', { cwd: dir, stdio: 'pipe', timeout: 60_000 });
+        execSync(`npm install ${pkgSpec} --no-audit --no-fund`, { cwd: dir, stdio: 'pipe', timeout: 120_000 });
+    }
+    installPython(packageName, version, dir) {
+        execSync('python -m venv venv', { cwd: dir, stdio: 'pipe', timeout: 60_000 });
+        const isWin = process.platform === 'win32';
+        const pip = isWin ? path.join(dir, 'venv', 'Scripts', 'pip.exe') : path.join(dir, 'venv', 'bin', 'pip');
+        const pkgSpec = version === 'latest' ? packageName : `${packageName}==${version}`;
+        execSync(`"${pip}" install ${pkgSpec}`, { cwd: dir, stdio: 'pipe', timeout: 120_000 });
+    }
+    getEntryCommand(name) {
+        const entry = this.installed.servers[name];
+        if (!entry)
+            return null;
+        const dir = entry.installPath;
+        const isWin = process.platform === 'win32';
+        if (entry.packageType === 'npm') {
+            // 从 node_modules/.bin/ 发现入口
+            const binDir = path.join(dir, 'node_modules', '.bin');
+            const binName = entry.package.split('/').pop();
+            const ext = isWin ? '.cmd' : '';
+            const binPath = path.join(binDir, binName + ext);
+            if (fs.existsSync(binPath)) {
+                return { command: binPath };
+            }
+            // 兜底：列出 .bin 中第一个可执行文件
+            if (fs.existsSync(binDir)) {
+                const bins = fs.readdirSync(binDir).filter(f => f.endsWith(ext));
+                if (bins.length > 0) {
+                    return { command: path.join(binDir, bins[0]) };
+                }
+            }
+            logger.warn(`No binary found for npm package "${entry.package}" in ${binDir}`);
+            return null;
+        }
+        if (entry.packageType === 'python') {
+            const py = isWin
+                ? path.join(dir, 'venv', 'Scripts', 'python.exe')
+                : path.join(dir, 'venv', 'bin', 'python');
+            return { command: py, args: ['-m', entry.package] };
+        }
+        return null;
+    }
+    verifyLocal(config) {
+        if (!config.command)
+            return null;
+        return { command: config.command, args: config.args };
+    }
+    loadIndex() {
+        try {
+            if (fs.existsSync(this.indexFilePath)) {
+                const raw = fs.readFileSync(this.indexFilePath, 'utf-8');
+                return JSON.parse(raw);
+            }
+        }
+        catch { /* 文件损坏则重新开始 */ }
+        return { servers: {} };
+    }
+    saveIndex() {
+        try {
+            fs.writeFileSync(this.indexFilePath, JSON.stringify(this.installed, null, 2), 'utf-8');
+        }
+        catch (err) {
+            logger.warn('Failed to save install index', { error: err.message });
+        }
+    }
+}
+//# sourceMappingURL=install-manager.js.map

package/dist/mcp/lifecycle.d.ts

@@ -0,0 +1,41 @@
+import { ProcessManager } from '../lifecycle/manager.js';
+import { MCPClient } from './client.js';
+import type { MCPConfig } from '../types.js';
+/**
+ * MCPServerManager — MCP Server 生命周期管理器。
+ *
+ * 职责：
+ *   1. 用 ProcessManager 管理 MCP Server 的 OS 进程（启动、监控、自动重启）
+ *   2. 用 MCPClient 管理 MCP 协议连接
+ *   3. 崩溃时自动重连 + 重新注册工具
+ *   4. 统一向 LifecycleSupervisor 报告状态
+ */
+export declare class MCPServerManager {
+    private config;
+    private processManager;
+    private client;
+    private reconnectTimer;
+    private _connected;
+    private reconnectAttempt;
+    private maxReconnectBackoff;
+    private logger;
+    constructor(config: MCPConfig);
+    /** 连接到 MCP Server */
+    connect(): Promise<boolean>;
+    /** 获取 MCPClient 实例 */
+    getClient(): MCPClient;
+    /** 是否已连接 */
+    isConnected(): boolean;
+    /** 获取服务名称 */
+    getName(): string;
+    /** 获取 ProcessManager（供 LifecycleSupervisor 注册） */
+    getProcessManager(): ProcessManager;
+    /** 断开连接 */
+    disconnect(): Promise<void>;
+    /** 重新连接 */
+    reconnect(): Promise<void>;
+    /** 处理崩溃 — 自动重连 + 重新注册工具 */
+    private handleCrash;
+    private stopReconnectTimer;
+}
+//# sourceMappingURL=lifecycle.d.ts.map

package/dist/mcp/lifecycle.js

@@ -0,0 +1,175 @@
+import { ProcessManager } from '../lifecycle/manager.js';
+import { MCPClient } from './client.js';
+import { ProcessTransport } from './process-transport.js';
+import { createLogger } from '../logging/logger.js';
+/**
+ * MCPServerManager — MCP Server 生命周期管理器。
+ *
+ * 职责：
+ *   1. 用 ProcessManager 管理 MCP Server 的 OS 进程（启动、监控、自动重启）
+ *   2. 用 MCPClient 管理 MCP 协议连接
+ *   3. 崩溃时自动重连 + 重新注册工具
+ *   4. 统一向 LifecycleSupervisor 报告状态
+ */
+export class MCPServerManager {
+    config;
+    processManager;
+    client;
+    reconnectTimer = null;
+    _connected = false;
+    reconnectAttempt = 0;
+    maxReconnectBackoff = 30000;
+    logger;
+    constructor(config) {
+        this.config = config;
+        this.logger = createLogger(`mcp:lifecycle:${config.name}`);
+        // ProcessManager 负责实际 spawn 和监控 MCP Server 子进程。
+        // 挂起检测策略：stdio MCP Server 无 HTTP 端点，无法配置 healthCheck；
+        // 依赖 onCrash 回调检测进程崩溃 + 工具调用超时（60s）检测进程挂起。
+        this.processManager = new ProcessManager({
+            name: `mcp-${config.name}`,
+            command: config.command ?? '',
+            args: config.args,
+            env: config.env,
+            autoRestart: false,
+            maxRestarts: 5,
+            restartDelayMs: 3000,
+            stopTimeoutMs: 8000,
+        }, {
+            onCrash: () => this.handleCrash(),
+        });
+        this.client = new MCPClient(config);
+    }
+    /** 连接到 MCP Server */
+    async connect() {
+        try {
+            if (this.config.url && !this.config.command) {
+                // SSE 远程传输：直接让 MCPClient 使用内部 SSE 传输逻辑
+                await this.client.connect();
+            }
+            else {
+                // stdio 传输：先启动子进程，再用 ProcessTransport 连接
+                await this.processManager.start();
+                const proc = this.processManager.getProcess();
+                if (!proc) {
+                    this._connected = false;
+                    return false;
+                }
+                const transport = new ProcessTransport(proc);
+                await this.client.connect(transport);
+            }
+            // 二次验证：确保 client 真正连接成功（防止 client.connect() 内部静默失败）
+            if (!this.client.isConnected()) {
+                this._connected = false;
+                this.logger.warn(`connect failed for ${this.config.name}: client reported not connected after connect()`);
+                return false;
+            }
+            this._connected = true;
+            return true;
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            this.logger.warn(`connect failed for ${this.config.name}: ${msg}`);
+            this._connected = false;
+            return false;
+        }
+    }
+    /** 获取 MCPClient 实例 */
+    getClient() {
+        return this.client;
+    }
+    /** 是否已连接 */
+    isConnected() {
+        return this._connected;
+    }
+    /** 获取服务名称 */
+    getName() {
+        return this.config.name;
+    }
+    /** 获取 ProcessManager（供 LifecycleSupervisor 注册） */
+    getProcessManager() {
+        return this.processManager;
+    }
+    /** 断开连接 */
+    async disconnect() {
+        this.stopReconnectTimer();
+        await this.client.disconnect();
+        if (this.config.command) {
+            await this.processManager.stop();
+        }
+        this._connected = false;
+    }
+    /** 重新连接 */
+    async reconnect() {
+        await this.disconnect();
+        if (this.config.url && !this.config.command) {
+            // SSE 远程传输：直接重连，无需管理子进程
+            try {
+                await this.client.connect();
+                if (!this.client.isConnected()) {
+                    this._connected = false;
+                    return;
+                }
+                this._connected = true;
+                this.reconnectAttempt = 0;
+                // 工具注册由 MCPSystem 统一管理，crash 恢复后 MCPSystem 会通过 syncBridge 重建
+            }
+            catch {
+                this._connected = false;
+            }
+        }
+        else {
+            // stdio 传输：重启子进程再连接
+            if (this.processManager.getState() !== 'running') {
+                await this.processManager.start();
+            }
+            const proc = this.processManager.getProcess();
+            if (!proc) {
+                this._connected = false;
+                return;
+            }
+            const transport = new ProcessTransport(proc);
+            try {
+                await this.client.connect(transport);
+                if (!this.client.isConnected()) {
+                    this._connected = false;
+                    return;
+                }
+                this._connected = true;
+                this.reconnectAttempt = 0;
+                // 工具注册由 MCPSystem 统一管理
+            }
+            catch {
+                this._connected = false;
+            }
+        }
+    }
+    /** 处理崩溃 — 自动重连 + 重新注册工具 */
+    async handleCrash() {
+        this._connected = false;
+        // 根据传输类型计算重连延迟
+        let delay;
+        if (this.config.url) {
+            // SSE 传输：指数退避
+            delay = Math.min(2000 * Math.pow(2, this.reconnectAttempt), this.maxReconnectBackoff);
+            this.reconnectAttempt++;
+        }
+        else {
+            // stdio 传输：固定延迟
+            delay = 2000;
+        }
+        // 延时后尝试重连
+        this.reconnectTimer = setTimeout(() => {
+            if (this._connected)
+                return;
+            void this.reconnect();
+        }, delay);
+    }
+    stopReconnectTimer() {
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
+    }
+}
+//# sourceMappingURL=lifecycle.js.map