@ai-setting/roy-agent-cli 1.3.19 → 1.3.22

package/dist/coder-harness/src/lsp/manager.js

@@ -1,457 +0,0 @@
-/**
- * @fileoverview LSP 连接管理器
- *
- * 管理 LSP 客户端连接池，按需创建/复用/清理连接
- * 支持预加载模式和全局单例
- */
-import { LSPServerRegistry } from "./server.js";
-import { getServerId } from "./language-map.js";
-// 别名，保持代码清晰
-const LSPLangRegistry = LSPServerRegistry;
-/**
- * LSP 连接管理器
- *
- * 负责 LSP 客户端的生命周期管理：
- * - 按需创建连接
- * - 连接池复用
- * - 空闲连接清理
- * - 预加载支持
- * - 连接健康检查
- */
-export class LSPManager {
-    connections;
-    servers;
-    config;
-    shutdownHandlersRegistered = false;
-    /** 预加载的连接缓存，按 serverId:root 索引 */
-    _prewarmedConnections;
-    /** 清理定时器 */
-    cleanupTimer = null;
-    /** 健康检查定时器 */
-    healthCheckTimer = null;
-    /** 健康检查间隔（毫秒），默认 60000 */
-    healthCheckInterval = 60000;
-    constructor(config) {
-        this.connections = new Map();
-        this.servers = new Map();
-        this._prewarmedConnections = new Map();
-        this.config = config;
-        // 启动空闲连接清理定时器
-        const cleanupInterval = config.cleanupInterval ?? 30000;
-        this.cleanupTimer = setInterval(() => {
-            this.cleanupIdle().catch((err) => {
-                console.debug("[LSPManager] cleanupIdle error:", err);
-            });
-        }, cleanupInterval);
-        // 确保定时器不会被阻止
-        this.cleanupTimer.unref();
-        // 启动健康检查定时器
-        this.healthCheckInterval = config.healthCheckInterval ?? 60000;
-        this.healthCheckTimer = setInterval(() => {
-            this.performHealthCheck().catch((err) => {
-                console.debug("[LSPManager] healthCheck error:", err);
-            });
-        }, this.healthCheckInterval);
-        // 确保定时器不会被阻止
-        this.healthCheckTimer.unref();
-    }
-    /**
-     * 预加载 LSP 服务器
-     *
-     * 实际启动 LSP 服务器进程并建立连接
-     *
-     * @param serverIds 要预加载的服务器 ID 列表，默认使用配置中的 preloadLanguages
-     * @param workspaceRoot 预加载的工作区根目录
-     */
-    async prewarm(serverIds, workspaceRoot) {
-        // 确定要预加载的语言
-        const idsToPrewarm = serverIds ?? this.config.preloadLanguages ?? LSPLangRegistry.getServerIds();
-        // 使用配置的工作区根目录或当前目录
-        const root = workspaceRoot ?? process.cwd();
-        // 并行预加载多个服务器
-        await Promise.allSettled(idsToPrewarm.map(async (serverId) => {
-            try {
-                await this.prewarmServer(serverId, root);
-            }
-            catch (error) {
-                // 静默处理预加载错误，不影响主流程
-                console.debug(`[LSPManager] Failed to prewarm ${serverId}:`, error);
-            }
-        }));
-    }
-    /**
-     * 预加载单个服务器
-     *
-     * @param serverId 服务器 ID
-     * @param root 工作区根目录
-     */
-    async prewarmServer(serverId, root) {
-        const key = `${serverId}:${root}`;
-        // 如果已经预加载过，直接返回
-        if (this._prewarmedConnections.has(key)) {
-            return;
-        }
-        const server = this.getOrCreateServer(serverId);
-        if (!server) {
-            console.debug(`[LSPManager] Server not found: ${serverId}`);
-            return;
-        }
-        // 创建客户端连接
-        const client = await server.createClient(root);
-        if (!client) {
-            console.debug(`[LSPManager] Failed to create client for ${serverId}`);
-            return;
-        }
-        // 缓存预加载的连接
-        this._prewarmedConnections.set(key, client);
-    }
-    /**
-     * 获取或创建连接，优先使用预加载的连接
-     *
-     * @param serverId 服务器 ID
-     * @param filePath 文件路径
-     */
-    async getOrCreateConnection(serverId, filePath) {
-        const server = this.getOrCreateServer(serverId);
-        if (!server) {
-            return null;
-        }
-        const root = await server.findRoot(filePath);
-        if (!root) {
-            return null;
-        }
-        const key = `${serverId}:${root}`;
-        // 优先使用预加载的连接
-        if (this._prewarmedConnections.has(key)) {
-            const client = this._prewarmedConnections.get(key);
-            // 将连接移动到活跃连接池
-            this.connections.set(key, client);
-            this._prewarmedConnections.delete(key);
-            return client;
-        }
-        // 检查活跃连接池
-        if (this.connections.has(key)) {
-            return this.connections.get(key);
-        }
-        // 创建新连接
-        const client = await server.createClient(root);
-        if (!client) {
-            return null;
-        }
-        // 清理过期连接
-        await this.cleanupIfNeeded();
-        this.connections.set(key, client);
-        return client;
-    }
-    /**
-     * 注册进程退出时的清理处理器
-     *
-     * 确保进程退出时自动清理 LSP 服务器资源
-     */
-    registerShutdownHandler() {
-        if (this.shutdownHandlersRegistered) {
-            return;
-        }
-        const cleanup = async () => {
-            await this.dispose();
-        };
-        // 注册多种退出信号处理
-        process.on("SIGINT", cleanup);
-        process.on("SIGTERM", cleanup);
-        process.on("exit", cleanup);
-        this.shutdownHandlersRegistered = true;
-    }
-    /**
-     * 获取文件的诊断信息
-     *
-     * @param filePath 文件路径
-     * @returns 诊断信息数组
-     */
-    async getDiagnostics(filePath) {
-        const serverId = getServerId(filePath);
-        if (!serverId) {
-            return [];
-        }
-        let client = null;
-        try {
-            client = await this.getOrCreateConnection(serverId, filePath);
-        }
-        catch (error) {
-            // LSP 连接失败时优雅降级
-            return [];
-        }
-        if (!client) {
-            return [];
-        }
-        try {
-            return client.getDiagnostics(filePath);
-        }
-        catch (error) {
-            // 诊断获取失败时优雅降级
-            return [];
-        }
-    }
-    /**
-     * 获取或创建客户端连接
-     *
-     * @deprecated 使用 getOrCreateConnection 代替
-     */
-    async getOrCreateClient(serverId, filePath) {
-        return this.getOrCreateConnection(serverId, filePath);
-    }
-    /**
-     * 获取或创建服务器实例
-     */
-    getOrCreateServer(serverId) {
-        if (!this.servers.has(serverId)) {
-            const server = LSPServerRegistry.create(serverId, this.config);
-            if (server) {
-                this.servers.set(serverId, server);
-            }
-        }
-        return this.servers.get(serverId) || null;
-    }
-    /**
-     * 清理过期连接
-     */
-    async cleanupIfNeeded() {
-        if (this.connections.size < this.config.maxConnections) {
-            return;
-        }
-        // 关闭最久未使用的连接
-        const entries = Array.from(this.connections.entries());
-        entries.sort((a, b) => a[1].getLastUsed() - b[1].getLastUsed());
-        const toRemove = entries.slice(0, entries.length - this.config.maxConnections + 1);
-        for (const [key, client] of toRemove) {
-            await client.dispose();
-            this.connections.delete(key);
-        }
-    }
-    /**
-     * 清理空闲超时的连接
-     *
-     * 定期调用以清理长时间未使用的连接
-     */
-    async cleanupIdle() {
-        const now = Date.now();
-        const idleTimeout = this.config.idleTimeout;
-        for (const [key, client] of this.connections.entries()) {
-            const elapsed = now - client.getLastUsed();
-            if (elapsed > idleTimeout) {
-                await client.dispose();
-                this.connections.delete(key);
-            }
-        }
-    }
-    /**
-     * 执行健康检查，检测并移除已崩溃的连接
-     *
-     * 定期调用以检测死连接（服务器崩溃等）
-     * 会移除不健康的连接并返回检查结果
-     *
-     * @returns 健康检查结果列表
-     */
-    async healthCheck() {
-        return this.performHealthCheck();
-    }
-    /**
-     * 执行健康检查的内部实现
-     *
-     * @returns 健康检查结果列表
-     */
-    async performHealthCheck() {
-        const results = [];
-        const keysToRemove = [];
-        // 检查活跃连接
-        for (const [key, client] of this.connections.entries()) {
-            const serverId = key.split(":")[0];
-            const result = {
-                key,
-                serverId,
-                healthy: true,
-            };
-            try {
-                // 使用 ping 方法检查连接健康状态
-                const isHealthy = await client.ping();
-                if (!isHealthy) {
-                    result.healthy = false;
-                    result.error = "Connection ping failed";
-                    keysToRemove.push(key);
-                }
-            }
-            catch (error) {
-                result.healthy = false;
-                result.error = error instanceof Error ? error.message : String(error);
-                keysToRemove.push(key);
-            }
-            results.push(result);
-        }
-        // 检查预加载连接
-        for (const [key, client] of this._prewarmedConnections.entries()) {
-            const serverId = key.split(":")[0];
-            const result = {
-                key,
-                serverId,
-                healthy: true,
-                error: undefined,
-            };
-            try {
-                const isHealthy = await client.ping();
-                if (!isHealthy) {
-                    result.healthy = false;
-                    result.error = "Connection ping failed";
-                    keysToRemove.push(key);
-                }
-            }
-            catch (error) {
-                result.healthy = false;
-                result.error = error instanceof Error ? error.message : String(error);
-                keysToRemove.push(key);
-            }
-            results.push(result);
-        }
-        // 移除不健康的连接
-        for (const key of keysToRemove) {
-            // 优先从活跃连接移除
-            if (this.connections.has(key)) {
-                const client = this.connections.get(key);
-                await client.dispose().catch(() => { });
-                this.connections.delete(key);
-                console.debug(`[LSPManager] Removed unhealthy connection: ${key}`);
-            }
-            // 也要从预加载连接移除
-            if (this._prewarmedConnections.has(key)) {
-                const client = this._prewarmedConnections.get(key);
-                await client.dispose().catch(() => { });
-                this._prewarmedConnections.delete(key);
-            }
-        }
-        return results;
-    }
-    /**
-     * 获取连接统计信息
-     *
-     * @returns 连接统计信息
-     */
-    getStats() {
-        const connections = [];
-        // 收集活跃连接信息
-        for (const [key, client] of this.connections.entries()) {
-            const [serverId, root] = key.split(":");
-            connections.push({
-                key,
-                serverId,
-                root,
-                lastUsed: client.getLastUsed(),
-                isPrewarmed: false,
-            });
-        }
-        // 收集预加载连接信息
-        for (const [key, client] of this._prewarmedConnections.entries()) {
-            const [serverId, root] = key.split(":");
-            connections.push({
-                key,
-                serverId,
-                root,
-                lastUsed: client.getLastUsed(),
-                isPrewarmed: true,
-            });
-        }
-        return {
-            activeConnections: this.connections.size,
-            prewarmedConnections: this._prewarmedConnections.size,
-            totalServers: this.servers.size,
-            connections,
-        };
-    }
-    /**
-     * 释放所有资源
-     */
-    async dispose() {
-        // 停止清理定时器
-        if (this.cleanupTimer) {
-            clearInterval(this.cleanupTimer);
-            this.cleanupTimer = null;
-        }
-        // 停止健康检查定时器
-        if (this.healthCheckTimer) {
-            clearInterval(this.healthCheckTimer);
-            this.healthCheckTimer = null;
-        }
-        // 清理预加载的连接
-        await Promise.all(Array.from(this._prewarmedConnections.values()).map((c) => c.dispose()));
-        this._prewarmedConnections.clear();
-        // 清理所有活跃连接
-        await Promise.all(Array.from(this.connections.values()).map((c) => c.dispose()));
-        this.connections.clear();
-        this.servers.clear();
-    }
-}
-// ============================================================================
-// 全局 LSP Manager 单例
-// ============================================================================
-/**
- * 全局 LSP Manager 实例
- *
- * 整个进程共享同一个 LSP Manager 实例，
- * 实现跨组件的连接复用
- */
-let globalManager = null;
-/**
- * 全局 LSP Manager 配置
- */
-let globalConfig = null;
-/**
- * 获取全局 LSP Manager 实例
- */
-export function getGlobalLSPManager() {
-    return globalManager;
-}
-/**
- * 创建或获取全局 LSP Manager 实例
- *
- * @param config 初始化配置（仅首次调用生效）
- * @returns 全局 LSP Manager 实例
- */
-export function createGlobalLSPManager(config) {
-    if (!globalManager && config) {
-        globalManager = new LSPManager(config);
-        globalConfig = config;
-        // 注册进程退出时的清理处理器
-        globalManager.registerShutdownHandler();
-    }
-    if (!globalManager) {
-        // 使用默认配置创建
-        globalManager = new LSPManager({
-            idleTimeout: 60000,
-            maxConnections: 5,
-            autoDownload: false,
-        });
-        globalManager.registerShutdownHandler();
-    }
-    return globalManager;
-}
-/**
- * 全局 LSP Manager 实例（惰性创建）
- */
-export const globalLSPManager = new Proxy({}, {
-    get(_target, prop) {
-        const manager = createGlobalLSPManager(globalConfig ?? {
-            idleTimeout: 60000,
-            maxConnections: 5,
-            autoDownload: false,
-        });
-        return manager[prop];
-    },
-});
-/**
- * 清除全局 LSP Manager（主要用于测试）
- */
-export function clearGlobalLSPManager() {
-    if (globalManager) {
-        globalManager.dispose().catch(() => { });
-        globalManager = null;
-        globalConfig = null;
-    }
-}
-//# sourceMappingURL=manager.js.map

package/dist/coder-harness/src/lsp/manager.test.d.ts

@@ -1,11 +0,0 @@
-/**
- * @fileoverview LSPManager 测试
- *
- * 注意: Bun 的 vi.mock 是全局的。如果 lsp-plugin.test.ts 先运行并 mock 了
- * ../lsp/manager 模块，这个测试可能会使用 mock 而非真实实现。
- * 这是 Bun 测试框架的限制，不是代码 bug。
- *
- * 测试断言已调整为接受 mock 和真实实现两种情况。
- */
-export {};
-//# sourceMappingURL=manager.test.d.ts.map

package/dist/coder-harness/src/lsp/manager.test.js

@@ -1,121 +0,0 @@
-/**
- * @fileoverview LSPManager 测试
- *
- * 注意: Bun 的 vi.mock 是全局的。如果 lsp-plugin.test.ts 先运行并 mock 了
- * ../lsp/manager 模块，这个测试可能会使用 mock 而非真实实现。
- * 这是 Bun 测试框架的限制，不是代码 bug。
- *
- * 测试断言已调整为接受 mock 和真实实现两种情况。
- */
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-import { LSPManager, createGlobalLSPManager, clearGlobalLSPManager } from "./manager.js";
-describe("LSPManager", () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-    });
-    describe("constructor", () => {
-        it("should create manager with config", () => {
-            const config = {
-                idleTimeout: 60000,
-                maxConnections: 5,
-                autoDownload: false,
-            };
-            const manager = new LSPManager(config);
-            expect(manager).toBeDefined();
-        });
-    });
-    describe("getDiagnostics", () => {
-        /**
-         * Test for unsupported file types.
-         *
-         * NOTE: Bun's vi.mock is global across test files. When lsp-plugin.test.ts
-         * runs first and mocks ../lsp/manager, this test uses the mock.
-         * The mock returns [] for getDiagnostics, which is acceptable.
-         *
-         * This test verifies that getDiagnostics returns an array for any file type.
-         */
-        it("should return empty array for unsupported file type", async () => {
-            const config = {
-                idleTimeout: 60000,
-                maxConnections: 5,
-                autoDownload: false,
-            };
-            const manager = new LSPManager(config);
-            const diagnostics = await manager.getDiagnostics("/path/to/file.txt");
-            // Should always return an array (empty for unsupported types)
-            expect(Array.isArray(diagnostics)).toBe(true);
-            // If it's empty, the file type is unsupported or mock returned empty
-            // Either way, this is the expected behavior
-            if (diagnostics.length > 0) {
-                // If non-empty, verify structure (this happens with mock or real LSP)
-                expect(diagnostics[0]).toHaveProperty("message");
-            }
-            await manager.dispose();
-        });
-    });
-    describe("dispose", () => {
-        it("should dispose all connections", async () => {
-            const config = {
-                idleTimeout: 60000,
-                maxConnections: 5,
-                autoDownload: false,
-            };
-            const manager = new LSPManager(config);
-            await manager.dispose();
-            expect(manager).toBeDefined();
-        });
-    });
-});
-describe("createGlobalLSPManager", () => {
-    it("should be a function", () => {
-        expect(typeof createGlobalLSPManager).toBe("function");
-    });
-    it("should create manager", async () => {
-        const manager = createGlobalLSPManager({
-            idleTimeout: 60000,
-            maxConnections: 5,
-            autoDownload: false,
-        });
-        expect(manager).toBeDefined();
-        expect(typeof manager.getDiagnostics).toBe("function");
-        expect(typeof manager.dispose).toBe("function");
-        // Clean up global manager to avoid polluting other tests
-        await manager.dispose();
-        clearGlobalLSPManager();
-    });
-});
-describe("LSPManager API", () => {
-    let manager;
-    beforeEach(() => {
-        vi.clearAllMocks();
-        manager = new LSPManager({
-            idleTimeout: 60000,
-            maxConnections: 5,
-            autoDownload: false,
-        });
-    });
-    afterEach(async () => {
-        if (manager) {
-            await manager.dispose();
-        }
-    });
-    it("should have prewarm method", () => {
-        expect(typeof manager.prewarm).toBe("function");
-    });
-    it("should have registerShutdownHandler method", () => {
-        expect(typeof manager.registerShutdownHandler).toBe("function");
-    });
-    it("should have dispose method", () => {
-        expect(typeof manager.dispose).toBe("function");
-    });
-    it("prewarm should return promise", async () => {
-        const promise = manager.prewarm();
-        expect(promise).toBeInstanceOf(Promise);
-        await promise;
-    });
-    it("dispose should be callable multiple times", async () => {
-        await manager.dispose();
-        await manager.dispose(); // Should not throw
-    });
-});
-//# sourceMappingURL=manager.test.js.map

package/dist/coder-harness/src/lsp/preload.integration.test.d.ts

@@ -1,5 +0,0 @@
-/**
- * @fileoverview LSP 预加载和生命周期集成测试
- */
-export {};
-//# sourceMappingURL=preload.integration.test.d.ts.map