zed-ets-language-server 1.1.1 → 2.0.1

package/index.js

@@ -2,82 +2,14 @@
 
 import { spawn } from 'node:child_process';
 import fs from 'node:fs';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
+import { logger } from './lib/logger.js';
+import { parse } from './lib/data-parser.js';
+import { listHelperPaths } from './lib/lib-expander.js'
 
 // ETS language server path, passed by Rust extension process through environment variable
 const etsLangServerPath = process.env.ETS_LANG_SERVER;
 
-function createSimpleLogger() {
-  if (process.env.ZED_ETS_LANG_SERVER_LOG !== 'true') {
-    const noop = (_msg) => {};
-    return {
-      info: noop,
-      success: noop,
-      error: console.error,
-      warn: noop,
-      section: noop,
-      data: noop,
-      close: noop,
-    };
-  }
-  // Create log file write stream
-  const logFilePath = path.join(__dirname, 'arkts-lsw.log');
-  const logStream = fs.createWriteStream(logFilePath, { flags: 'w+' });
-
-  // Function to get current timestamp
-  const getTimestamp = () => {
-    const now = new Date();
-    return now.toISOString().slice(0, 19).replace('T', ' ');
-  };
-
-  // Logging utility
-  const logger = {
-    info: (msg) => {
-      const timestamp = getTimestamp();
-      const logMsg = `[${timestamp}] ℹ ${msg}\n`;
-      logStream.write(logMsg);
-    },
-    success: (msg) => {
-      const timestamp = getTimestamp();
-      const logMsg = `[${timestamp}] ✓ ${msg}\n`;
-      logStream.write(logMsg);
-    },
-    error: (msg) => {
-      const timestamp = getTimestamp();
-      const logMsg = `[${timestamp}] ✗ ${msg}\n`;
-      logStream.write(logMsg);
-      process.stderr.write(logMsg);
-    },
-    warn: (msg) => {
-      const timestamp = getTimestamp();
-      const logMsg = `[${timestamp}] ⚠ ${msg}\n`;
-      logStream.write(logMsg);
-    },
-    section: (msg) => {
-      const timestamp = getTimestamp();
-      const logMsg = `\n[${timestamp}] ${msg}\n\n`;
-      logStream.write(logMsg);
-    },
-    data: (label, data) => {
-      const timestamp = getTimestamp();
-      const logMsg = `[${timestamp}]   ${label}: ${JSON.stringify(data, null, 2)}\n`;
-      logStream.write(logMsg);
-    },
-    // Add method to close log stream
-    close: () => {
-      logStream.end();
-    },
-  };
-
-  return logger;
-}
-
 async function main() {
-  const logger = createSimpleLogger();
   logger.section('🚀 ETS Language Server Wrapper');
 
   // Check if language server exists
@@ -116,55 +48,43 @@ async function main() {
   });
 
   // Set up forwarding of process.stdin to serverProcess IPC
-  let stdinBuffer = '';
-  process.stdin.on('data', (data) => {
-    stdinBuffer += data.toString();
-
-    while (true) {
-      // Find Content-Length header
-      const lengthMatch = stdinBuffer.match(/Content-Length: (\d+)\r\n/);
-      if (!lengthMatch) break;
-
-      const contentLength = Number.parseInt(lengthMatch[1]);
-      const headerEnd = stdinBuffer.indexOf('\r\n\r\n');
-
-      if (headerEnd === -1) break;
-
-      const messageStart = headerEnd + 4;
-      const messageEnd = messageStart + contentLength;
-
-      if (stdinBuffer.length < messageEnd) break;
-
-      // Extract message
-      const messageJson = stdinBuffer.substring(messageStart, messageEnd);
-      stdinBuffer = stdinBuffer.substring(messageEnd);
-
-      try {
-        const message = JSON.parse(messageJson);
-        // Send message to language server via IPC
-        serverProcess.send(message);
-
-        // This special ets request is required in document: https://github.com/ohosvscode/arkTS/tree/next/packages/language-server
-        // When this goes wrong, ETS UI decorators and functions will be type of any
-        if (message.method === 'initialize') {
-          const { initializationOptions } = message.params;
-          const etsSpecialRequest = {
-            jsonrpc: '2.0',
-            id: Date.now(),
-            method: 'ets/waitForEtsConfigurationChangedRequested',
-            params: {
-              typescript: initializationOptions.typescript,
-              ohos: initializationOptions.ohos,
-              debug: initializationOptions.debug,
-            },
-          };
-          serverProcess.send(etsSpecialRequest);
-        }
-      } catch (error) {
-        logger.error(`Failed to parse message from stdin: ${error.message}, ${messageJson}`);
-      }
+  process.stdin.setEncoding('utf8');
+  process.stdin.on('data', (data) => parse(data, async (message) => {
+    // This special ets request is required in document: https://github.com/ohosvscode/arkTS/tree/next/packages/language-server
+    // When this goes wrong, ETS UI decorators and functions will be type of any
+    if (message.method === 'initialize') {
+      const { initializationOptions } = message.params;
+
+      const ohos = await listHelperPaths(initializationOptions.tsdk, initializationOptions.ohosSdkPath);
+
+      const etsSpecialRequest = {
+        jsonrpc: '2.0',
+        id: Date.now(),
+        method: 'ets/waitForEtsConfigurationChangedRequested',
+        params: {
+          typescript: {
+            tsdk: initializationOptions.tsdk,
+          },
+          ohos: ohos,
+        },
+      };
+
+      const generalInitRequest = message;
+      generalInitRequest.params.initializationOptions.typescript = {
+        tsdk: initializationOptions.tsdk,
+      };
+      generalInitRequest.params.initializationOptions.ohos = ohos;
+      
+      logger.info(JSON.stringify(generalInitRequest));
+      logger.info(JSON.stringify(etsSpecialRequest));
+      
+      serverProcess.send(generalInitRequest);
+      serverProcess.send(etsSpecialRequest);
+      return;
     }
-  });
+    // Send message to language server via IPC
+    serverProcess.send(message);
+  }));
 
   // Error handling
   process.on('SIGTERM', () => {

package/lib/data-parser.js

@@ -0,0 +1,38 @@
+import { logger } from './logger.js';
+
+let stdinBuffer = '';
+
+export function parse(data, callback) {
+  stdinBuffer += data.toString();
+
+  while (true) {
+    // Find Content-Length header
+    const lengthMatch = stdinBuffer.match(/Content-Length: (\d+)\r\n/);
+    if (!lengthMatch) break;
+
+    const contentLength = Number.parseInt(lengthMatch[1]);
+    const headerEnd = stdinBuffer.indexOf('\r\n\r\n');
+
+    if (headerEnd === -1) break;
+
+    const messageStart = headerEnd + 4;
+    const messageEnd = messageStart + contentLength;
+
+    if (stdinBuffer.length < messageEnd) break;
+
+    // Extract message
+    const messageJson = stdinBuffer.substring(messageStart, messageEnd);
+    stdinBuffer = stdinBuffer.substring(messageEnd);
+
+    try {
+      const message = JSON.parse(messageJson);
+      callback(message);
+    } catch (error) {
+      logger.error(`Error parsing message: ${error.message} ${error.stack}`);
+    }
+  }
+}
+
+export function clearBuffer() {
+  stdinBuffer = '';
+}

package/lib/data-parser.test.js

@@ -0,0 +1,279 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { parse, clearBuffer } from './data-parser.js';
+
+// Mock the logger module
+vi.mock('./logger.js', () => ({
+  logger: {
+    error: vi.fn(),
+  },
+}));
+
+describe('data-parser', () => {
+  beforeEach(() => {
+    // Clear buffer before each test
+    clearBuffer();
+    vi.clearAllMocks();
+  });
+
+  afterEach(() => {
+    // Clear buffer after each test
+    clearBuffer();
+  });
+
+  describe('parse', () => {
+    it('should parse a complete message with Content-Length header', (done) => {
+      const message = { jsonrpc: '2.0', method: 'initialize', id: 1 };
+      const messageJson = JSON.stringify(message);
+      const data = Buffer.from(`Content-Length: ${messageJson.length}\r\n\r\n${messageJson}`);
+      
+      const callback = vi.fn((parsedMessage) => {
+        expect(parsedMessage).toEqual(message);
+        expect(callback).toHaveBeenCalledTimes(1);
+        done();
+      });
+
+      parse(data, callback);
+    });
+
+    it('should handle multiple messages in one buffer', () => {
+      const message1 = { jsonrpc: '2.0', method: 'initialize', id: 1 };
+      const message2 = { jsonrpc: '2.0', method: 'initialized' };
+      
+      const messageJson1 = JSON.stringify(message1);
+      const messageJson2 = JSON.stringify(message2);
+      
+      const data = Buffer.from(
+        `Content-Length: ${messageJson1.length}\r\n\r\n${messageJson1}` +
+        `Content-Length: ${messageJson2.length}\r\n\r\n${messageJson2}`
+      );
+      
+      const callback = vi.fn();
+      parse(data, callback);
+
+      expect(callback).toHaveBeenCalledTimes(2);
+      expect(callback).toHaveBeenNthCalledWith(1, message1);
+      expect(callback).toHaveBeenNthCalledWith(2, message2);
+    });
+
+    it('should handle partial messages across multiple parse calls', (done) => {
+      const message = { jsonrpc: '2.0', method: 'initialize', id: 1 };
+      const messageJson = JSON.stringify(message);
+      
+      // Split the data into two parts
+      const headerPart = `Content-Length: ${messageJson.length}\r\n\r\n`;
+      const messagePart = messageJson;
+      
+      const callback = vi.fn((parsedMessage) => {
+        expect(parsedMessage).toEqual(message);
+        expect(callback).toHaveBeenCalledTimes(1);
+        done();
+      });
+
+      // First call with just the header
+      parse(Buffer.from(headerPart), callback);
+      expect(callback).not.toHaveBeenCalled();
+      
+      // Second call with the message
+      parse(Buffer.from(messagePart), callback);
+    });
+
+    it('should handle message with additional headers', (done) => {
+      const message = { jsonrpc: '2.0', method: 'initialize', id: 1 };
+      const messageJson = JSON.stringify(message);
+      const data = Buffer.from(
+        `Content-Type: application/vscode-jsonrpc; charset=utf-8\r\n` +
+        `Content-Length: ${messageJson.length}\r\n\r\n${messageJson}`
+      );
+      
+      const callback = vi.fn((parsedMessage) => {
+        expect(parsedMessage).toEqual(message);
+        expect(callback).toHaveBeenCalledTimes(1);
+        done();
+      });
+
+      parse(data, callback);
+    });
+
+    it('should ignore incomplete messages and wait for more data', () => {
+      const message = { jsonrpc: '2.0', method: 'initialize', id: 1 };
+      const messageJson = JSON.stringify(message);
+      
+      // Send header but not the complete message
+      const incompleteData = Buffer.from(
+        `Content-Length: ${messageJson.length}\r\n\r\n${messageJson.substring(0, 10)}`
+      );
+      
+      const callback = vi.fn();
+      parse(incompleteData, callback);
+      
+      expect(callback).not.toHaveBeenCalled();
+    });
+
+    it('should ignore data without Content-Length header', () => {
+      const data = Buffer.from('Some random data without proper headers');
+      const callback = vi.fn();
+      
+      parse(data, callback);
+      
+      expect(callback).not.toHaveBeenCalled();
+    });
+
+    it('should ignore data with invalid Content-Length', () => {
+      const data = Buffer.from('Content-Length: invalid\r\n\r\n{}');
+      const callback = vi.fn();
+      
+      parse(data, callback);
+      
+      expect(callback).not.toHaveBeenCalled();
+    });
+
+    it('should ignore data with negative Content-Length', () => {
+      const data = Buffer.from('Content-Length: -10\r\n\r\n{}');
+      const callback = vi.fn();
+      
+      parse(data, callback);
+      
+      expect(callback).not.toHaveBeenCalled();
+    });
+
+    it('should ignore data with Content-Length header but no message terminator', () => {
+      const data = Buffer.from('Content-Length: 2\r\n');
+      const callback = vi.fn();
+      
+      parse(data, callback);
+      
+      expect(callback).not.toHaveBeenCalled();
+    });
+
+    it('should handle JSON parsing errors gracefully', async () => {
+      const invalidJson = '{ invalid json }';
+      const data = Buffer.from(`Content-Length: ${invalidJson.length}\r\n\r\n${invalidJson}`);
+      
+      const { logger } = await import('./logger.js');
+      const callback = vi.fn();
+      
+      parse(data, callback);
+      
+      expect(callback).not.toHaveBeenCalled();
+      expect(logger.error).toHaveBeenCalledWith(
+        expect.stringContaining('Error parsing message:')
+      );
+    });
+
+    it('should handle empty message content', () => {
+      const data = Buffer.from('Content-Length: 0\r\n\r\n');
+      const callback = vi.fn();
+      
+      parse(data, callback);
+      
+      expect(callback).not.toHaveBeenCalled();
+    });
+
+    it('should preserve buffer state across multiple parse calls', () => {
+      const message1 = { jsonrpc: '2.0', method: 'initialize', id: 1 };
+      const messageJson1 = JSON.stringify(message1);
+      
+      // First, send partial data
+      const partialHeader = 'Content-Length: ';
+      parse(Buffer.from(partialHeader), () => {});
+      
+      // Then send the rest
+      const restOfData = `${messageJson1.length}\r\n\r\n${messageJson1}`;
+      const callback = vi.fn();
+      parse(Buffer.from(restOfData), callback);
+      
+      expect(callback).toHaveBeenCalledWith(message1);
+    });
+
+    it('should handle complex JSON messages with nested objects', (done) => {
+      const message = {
+        jsonrpc: '2.0',
+        method: 'textDocument/completion',
+        params: {
+          textDocument: { uri: 'file:///test.ets' },
+          position: { line: 10, character: 5 },
+          context: { triggerKind: 1 }
+        },
+        id: 2
+      };
+      
+      const messageJson = JSON.stringify(message);
+      const data = Buffer.from(`Content-Length: ${messageJson.length}\r\n\r\n${messageJson}`);
+      
+      const callback = vi.fn((parsedMessage) => {
+        expect(parsedMessage).toEqual(message);
+        expect(callback).toHaveBeenCalledTimes(1);
+        done();
+      });
+
+      parse(data, callback);
+    });
+
+    it('should handle Unicode characters in messages', (done) => {
+      const message = { 
+        jsonrpc: '2.0', 
+        method: 'textDocument/publishDiagnostics',
+        params: {
+          uri: 'file:///test.ets',
+          diagnostics: [{
+            message: '测试消息 with émojis 🚀',
+            range: { start: { line: 0, character: 0 }, end: { line: 0, character: 10 } }
+          }]
+        }
+      };
+      
+      const messageJson = JSON.stringify(message);
+      const data = Buffer.from(`Content-Length: ${messageJson.length}\r\n\r\n${messageJson}`);
+      
+      const callback = vi.fn((parsedMessage) => {
+        expect(parsedMessage).toEqual(message);
+        expect(callback).toHaveBeenCalledTimes(1);
+        done();
+      });
+
+      parse(data, callback);
+    });
+  });
+
+  describe('clearBuffer', () => {
+    it('should reset the internal buffer to empty', () => {
+      // First add some data to the buffer
+      const partialData = Buffer.from('Content-Length: 50\r\n');
+      parse(partialData, () => {});
+      
+      // Clear the buffer
+      clearBuffer();
+      
+      // Try to parse again - should not process any data
+      const message = { jsonrpc: '2.0', method: 'initialize', id: 1 };
+      const messageJson = JSON.stringify(message);
+      const completeData = Buffer.from(`\r\n\r\n${messageJson}`);
+      const callback = vi.fn();
+      
+      parse(completeData, callback);
+      expect(callback).not.toHaveBeenCalled();
+    });
+
+    it('should allow fresh parsing after clearing buffer', (done) => {
+      // Add some incomplete data
+      const incompleteData = Buffer.from('Content-Length: 10\r\n');
+      parse(incompleteData, () => {});
+      
+      // Clear buffer
+      clearBuffer();
+      
+      // Now send a complete message
+      const message = { jsonrpc: '2.0', method: 'initialize', id: 1 };
+      const messageJson = JSON.stringify(message);
+      const completeData = Buffer.from(`Content-Length: ${messageJson.length}\r\n\r\n${messageJson}`);
+      
+      const callback = vi.fn((parsedMessage) => {
+        expect(parsedMessage).toEqual(message);
+        expect(callback).toHaveBeenCalledTimes(1);
+        done();
+      });
+      
+      parse(completeData, callback);
+    });
+  });
+});

package/lib/lib-expander.js

@@ -0,0 +1,94 @@
+import fs from 'fs/promises';
+import path from 'path';
+
+/**
+ * 根据提供的路径，返回其中所有符合正则要求文件名的文件名列表
+ * @param {string} dirPath - 要搜索的目录路径
+ * @param {RegExp} pattern - 用于匹配文件名的正则表达式
+ * @param {boolean} recursive - 是否递归搜索子目录，默认为 true
+ * @returns {Promise<string[]>} 符合条件的文件名列表的 Promise
+ */
+export async function getFilesByPattern(dirPath, pattern, recursive = true) {
+  const result = [];
+  
+  try {
+    // 检查路径是否存在
+    try {
+      await fs.access(dirPath);
+    } catch (error) {
+      console.warn(`路径不存在: ${dirPath}`);
+      return result;
+    }
+  
+    // 检查是否为目录
+    const stat = await fs.stat(dirPath);
+    if (!stat.isDirectory()) {
+      console.warn(`路径不是目录: ${dirPath}`);
+      return result;
+    }
+  
+    // 读取目录内容
+    const items = await fs.readdir(dirPath);
+    
+    // 使用 Promise.all 并行处理所有项目
+    const promises = items.map(async (item) => {
+      const fullPath = path.join(dirPath, item);
+      
+      try {
+        const itemStat = await fs.stat(fullPath);
+
+        if (itemStat.isDirectory() && recursive) {
+          // 递归搜索子目录
+          const subResult = await getFilesByPattern(fullPath, pattern, recursive);
+          return subResult;
+        } else if (itemStat.isFile()) {
+          // 检查文件名是否匹配正则表达式
+          if (pattern.test(fullPath)) {
+            return [fullPath];
+          }
+        }
+      } catch (error) {
+        console.error(`处理文件/目录时出错: ${fullPath}`, error.message);
+      }
+
+      return [];
+    });
+
+    // 等待所有 Promise 完成
+    const results = await Promise.all(promises);
+
+    // 合并所有结果
+    for (const subResult of results) {
+      result.push(...subResult);
+    }
+
+  } catch (error) {
+    console.error(`读取目录时出错: ${dirPath}`, error.message);
+  }
+  
+  return result;
+}
+
+export async function listLibs(dirPath) {
+  return await getFilesByPattern(dirPath, /d\.ts$/i);
+}
+
+export async function listHelperPaths(tsDir, harmonyDir) {
+  const etsComponentPath = path.join(harmonyDir, '/ets/component');
+  const etsLoaderConfigPath = path.join(harmonyDir, '/ets/build-tools/ets-loader/tsconfig.json');
+  const etsLoaderPath = path.join(harmonyDir, '/ets/build-tools/ets-loader');
+  const etsLoaderLibs = await listLibs(path.join(etsLoaderPath, '/declarations'));
+
+  return {
+    sdkPath: harmonyDir,
+    etsComponentPath,
+    etsLoaderConfigPath,
+    etsLoaderPath,
+    baseUrl: path.join(harmonyDir, '/ets'),
+    lib: [...(await listLibs(tsDir)), ...(await listLibs(etsComponentPath)), ...etsLoaderLibs],
+    "paths": {
+      "*": ["./api/*", "./kits/*", "./arkts/*"],
+      "@internal/full/*": ["./api/@internal/full/*"]
+    },
+  };
+}

package/lib/lib-expander.test.js

@@ -0,0 +1,342 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { getFilesByPattern, listLibs, listHelperPaths } from './lib-expander.js';
+import fs from 'fs/promises';
+import path from 'path';
+
+// Mock fs module
+vi.mock('fs/promises');
+
+// Mock console methods
+const originalConsoleWarn = console.warn;
+const originalConsoleError = console.error;
+
+describe('lib-expander', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    console.warn = vi.fn();
+    console.error = vi.fn();
+  });
+
+  afterEach(() => {
+    console.warn = originalConsoleWarn;
+    console.error = originalConsoleError;
+  });
+
+  describe('getFilesByPattern', () => {
+    it('should return an empty array when directory does not exist', async () => {
+      fs.access.mockRejectedValue(new Error('ENOENT: no such file or directory'));
+      
+      const result = await getFilesByPattern('/nonexistent/path', /\.ts$/);
+      
+      expect(result).toEqual([]);
+      expect(console.warn).toHaveBeenCalledWith('路径不存在: /nonexistent/path');
+    });
+
+    it('should return an empty array when path is not a directory', async () => {
+      fs.access.mockResolvedValue();
+      fs.stat.mockResolvedValue({ isDirectory: () => false });
+      
+      const result = await getFilesByPattern('/some/file.txt', /\.ts$/);
+      
+      expect(result).toEqual([]);
+      expect(console.warn).toHaveBeenCalledWith('路径不是目录: /some/file.txt');
+    });
+
+    it('should return matching files from a directory', async () => {
+      const mockFiles = ['file1.ts', 'file2.js', 'file3.ts', 'file4.txt'];
+      const mockFileStats = {
+        isDirectory: () => false,
+        isFile: () => true
+      };
+      const mockDirStats = {
+        isDirectory: () => true,
+        isFile: () => false
+      };
+
+      fs.access.mockResolvedValue();
+      fs.readdir.mockResolvedValue(mockFiles);
+      
+      fs.stat.mockImplementation((filePath) => {
+        if (filePath === '/test/dir') {
+          return Promise.resolve(mockDirStats);
+        }
+        if (filePath.includes('file1.ts') || filePath.includes('file2.js') || 
+            filePath.includes('file3.ts') || filePath.includes('file4.txt')) {
+          return Promise.resolve(mockFileStats);
+        }
+        return Promise.reject(new Error('File not found'));
+      });
+
+      const pattern = /\.ts$/;
+      const result = await getFilesByPattern('/test/dir', pattern);
+
+      expect(result).toEqual([
+        path.join('/test/dir', 'file1.ts'),
+        path.join('/test/dir', 'file3.ts')
+      ]);
+    });
+
+    it('should search recursively when recursive is true', async () => {
+      const mockFiles = ['file1.ts', 'subdir'];
+      const mockSubFiles = ['file2.ts', 'file3.js'];
+      const mockFileStats = {
+        isDirectory: () => false,
+        isFile: () => true
+      };
+      const mockDirStats = {
+        isDirectory: () => true,
+        isFile: () => false
+      };
+
+      fs.access.mockResolvedValue();
+      
+      fs.readdir.mockImplementation((dirPath) => {
+        if (dirPath === '/test/dir') {
+          return Promise.resolve(mockFiles);
+        } else if (dirPath === '/test/dir/subdir') {
+          return Promise.resolve(mockSubFiles);
+        }
+        return Promise.reject(new Error('Directory not found'));
+      });
+
+      fs.stat.mockImplementation((filePath) => {
+        if (filePath === '/test/dir' || filePath === '/test/dir/subdir') {
+          return Promise.resolve(mockDirStats);
+        }
+        if (filePath.includes('file1.ts') || filePath.includes('file2.ts') || 
+            filePath.includes('file3.js')) {
+          return Promise.resolve(mockFileStats);
+        }
+        return Promise.reject(new Error('File not found'));
+      });
+
+      const pattern = /\.ts$/;
+      const result = await getFilesByPattern('/test/dir', pattern, true);
+
+      expect(result).toContain(path.join('/test/dir', 'file1.ts'));
+      expect(result).toContain(path.join('/test/dir', 'subdir', 'file2.ts'));
+      expect(result.length).toBeGreaterThan(0);
+    });
+
+    it('should not search recursively when recursive is false', async () => {
+      const mockFiles = ['file1.ts', 'subdir'];
+      const mockFileStats = {
+        isDirectory: () => false,
+        isFile: () => true
+      };
+      const mockDirStats = {
+        isDirectory: () => true,
+        isFile: () => false
+      };
+
+      fs.access.mockResolvedValue();
+      fs.readdir.mockResolvedValue(mockFiles);
+
+      fs.stat.mockImplementation((filePath) => {
+        if (filePath === '/test/dir') {
+          return Promise.resolve(mockDirStats);
+        }
+        if (filePath.includes('subdir')) {
+          return Promise.resolve(mockDirStats);
+        }
+        if (filePath.includes('file1.ts')) {
+          return Promise.resolve(mockFileStats);
+        }
+        return Promise.reject(new Error('File not found'));
+      });
+
+      const pattern = /\.ts$/;
+      const result = await getFilesByPattern('/test/dir', pattern, false);
+
+      expect(result).toEqual([path.join('/test/dir', 'file1.ts')]);
+    });
+
+    it('should handle file reading errors gracefully', async () => {
+      fs.access.mockResolvedValue();
+      fs.stat.mockResolvedValue({ isDirectory: () => true });
+      fs.readdir.mockResolvedValue(['file1.ts']);
+      fs.stat.mockRejectedValue(new Error('Permission denied'));
+
+      const result = await getFilesByPattern('/test/dir', /\.ts$/);
+
+      expect(result).toEqual([]);
+      expect(console.error).toHaveBeenCalled();
+    });
+
+    it('should handle directory reading errors gracefully', async () => {
+      fs.access.mockResolvedValue();
+      fs.stat.mockResolvedValue({ isDirectory: () => true });
+      fs.readdir.mockRejectedValue(new Error('Permission denied'));
+
+      const result = await getFilesByPattern('/test/dir', /\.ts$/);
+
+      expect(result).toEqual([]);
+      expect(console.error).toHaveBeenCalledWith('读取目录时出错: /test/dir', 'Permission denied');
+    });
+
+    it('should return empty array when no files match pattern', async () => {
+      const mockFiles = ['file1.js', 'file2.txt', 'file3.json'];
+      const mockFileStats = {
+        isDirectory: () => false,
+        isFile: () => true
+      };
+      const mockDirStats = {
+        isDirectory: () => true,
+        isFile: () => false
+      };
+
+      fs.access.mockResolvedValue();
+      fs.readdir.mockResolvedValue(mockFiles);
+
+      fs.stat.mockImplementation((filePath) => {
+        if (filePath === '/test/dir') {
+          return Promise.resolve(mockDirStats);
+        }
+        return Promise.resolve(mockFileStats);
+      });
+
+      const pattern = /\.ts$/;
+      const result = await getFilesByPattern('/test/dir', pattern);
+
+      expect(result).toEqual([]);
+    });
+
+    it('should handle empty directory', async () => {
+      fs.access.mockResolvedValue();
+      fs.stat.mockResolvedValue({ isDirectory: () => true });
+      fs.readdir.mockResolvedValue([]);
+
+      const result = await getFilesByPattern('/empty/dir', /\.ts$/);
+
+      expect(result).toEqual([]);
+    });
+  });
+
+  describe('listLibs', () => {
+    it('should call getFilesByPattern with d.ts pattern', async () => {
+      const mockFiles = ['lib.d.ts', 'file.js', 'test.d.ts', 'node.d.ts'];
+      const mockFileStats = {
+        isDirectory: () => false,
+        isFile: () => true
+      };
+      const mockDirStats = {
+        isDirectory: () => true,
+        isFile: () => false
+      };
+
+      fs.access.mockResolvedValue();
+      fs.readdir.mockResolvedValue(mockFiles);
+
+      fs.stat.mockImplementation((filePath) => {
+        if (filePath === '/test/path') {
+          return Promise.resolve(mockDirStats);
+        }
+        if (filePath.includes('lib.d.ts') || filePath.includes('file.js') || 
+            filePath.includes('test.d.ts') || filePath.includes('node.d.ts')) {
+          return Promise.resolve(mockFileStats);
+        }
+        return Promise.reject(new Error('File not found'));
+      });
+
+      const result = await listLibs('/test/path');
+
+      expect(result).toEqual([
+        path.join('/test/path', 'lib.d.ts'),
+        path.join('/test/path', 'test.d.ts'),
+        path.join('/test/path', 'node.d.ts')
+      ]);
+    });
+
+    it('should be case insensitive for .ts extension', async () => {
+      const mockFiles = ['lib.D.TS', 'test.d.Ts'];
+      const mockFileStats = {
+        isDirectory: () => false,
+        isFile: () => true
+      };
+      const mockDirStats = {
+        isDirectory: () => true,
+        isFile: () => false
+      };
+
+      fs.access.mockResolvedValue();
+      fs.readdir.mockResolvedValue(mockFiles);
+
+      fs.stat.mockImplementation((filePath) => {
+        if (filePath === '/test/path') {
+          return Promise.resolve(mockDirStats);
+        }
+        if (filePath.includes('lib.D.TS') || filePath.includes('test.d.Ts')) {
+          return Promise.resolve(mockFileStats);
+        }
+        return Promise.reject(new Error('File not found'));
+      });
+
+      const result = await listLibs('/test/path');
+
+      expect(result).toEqual([
+        path.join('/test/path', 'lib.D.TS'),
+        path.join('/test/path', 'test.d.Ts')
+      ]);
+    });
+
+    it('should return empty array when no d.ts files found', async () => {
+      const mockFiles = ['file.js', 'test.txt', 'node.json'];
+      const mockFileStats = {
+        isDirectory: () => false,
+        isFile: () => true
+      };
+      const mockDirStats = {
+        isDirectory: () => true,
+        isFile: () => false
+      };
+
+      fs.access.mockResolvedValue();
+      fs.readdir.mockResolvedValue(mockFiles);
+
+      fs.stat.mockImplementation((filePath) => {
+        if (filePath === '/test/path') {
+          return Promise.resolve(mockDirStats);
+        }
+        return Promise.resolve(mockFileStats);
+      });
+
+      const result = await listLibs('/test/path');
+
+      expect(result).toEqual([]);
+    });
+  });
+
+  describe('listHelperPaths', () => {
+    it('should return helper paths structure with correct properties', async () => {
+      const harmonyDir = '/harmony/sdk';
+      const tsDir = '/ts/lib';
+      
+      // Mock the file system operations
+      fs.access.mockResolvedValue();
+      fs.readdir.mockResolvedValue([]);
+      
+      const mockDirStats = {
+        isDirectory: () => true,
+        isFile: () => false
+      };
+
+      fs.stat.mockImplementation((filePath) => {
+        return Promise.resolve(mockDirStats);
+      });
+
+      const result = await listHelperPaths(tsDir, harmonyDir);
+
+      expect(result).toHaveProperty('sdkPath', harmonyDir);
+      expect(result).toHaveProperty('etsComponentPath', path.join(harmonyDir, '/ets/component'));
+      expect(result).toHaveProperty('etsLoaderConfigPath', path.join(harmonyDir, '/ets/build-tools/ets-loader/tsconfig.json'));
+      expect(result).toHaveProperty('etsLoaderPath', path.join(harmonyDir, '/ets/build-tools/ets-loader'));
+      expect(result).toHaveProperty('baseUrl', path.join(harmonyDir, '/ets'));
+      expect(result).toHaveProperty('lib');
+      expect(result).toHaveProperty('paths');
+      expect(result.paths).toEqual({
+        "*": ["./api/*", "./kits/*", "./arkts/*"],
+        "@internal/full/*": ["./api/@internal/full/*"]
+      });
+    });
+  });
+});

package/lib/logger.js

@@ -0,0 +1,73 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+export function createSimpleLogger() {
+  if (process.env.ZED_ETS_LANG_SERVER_LOG !== 'true') {
+    const noop = (_msg) => {};
+    return {
+      info: noop,
+      success: noop,
+      error: console.error,
+      warn: noop,
+      section: noop,
+      data: noop,
+      close: noop,
+    };
+  }
+  // Create log file write stream
+  const logFilePath = path.join(__dirname, 'arkts-lsw.log');
+  const logStream = fs.createWriteStream(logFilePath, { flags: 'w+' });
+
+  // Function to get current timestamp
+  const getTimestamp = () => {
+    const now = new Date();
+    return now.toISOString().slice(0, 19).replace('T', ' ');
+  };
+
+  // Logging utility
+  const logger = {
+    info: (msg) => {
+      const timestamp = getTimestamp();
+      const logMsg = `[${timestamp}] ℹ ${msg}\n`;
+      logStream.write(logMsg);
+    },
+    success: (msg) => {
+      const timestamp = getTimestamp();
+      const logMsg = `[${timestamp}] ✓ ${msg}\n`;
+      logStream.write(logMsg);
+    },
+    error: (msg) => {
+      const timestamp = getTimestamp();
+      const logMsg = `[${timestamp}] ✗ ${msg}\n`;
+      logStream.write(logMsg);
+      process.stderr.write(logMsg);
+    },
+    warn: (msg) => {
+      const timestamp = getTimestamp();
+      const logMsg = `[${timestamp}] ⚠ ${msg}\n`;
+      logStream.write(logMsg);
+    },
+    section: (msg) => {
+      const timestamp = getTimestamp();
+      const logMsg = `\n[${timestamp}] ${msg}\n\n`;
+      logStream.write(logMsg);
+    },
+    data: (label, data) => {
+      const timestamp = getTimestamp();
+      const logMsg = `[${timestamp}]   ${label}: ${JSON.stringify(data, null, 2)}\n`;
+      logStream.write(logMsg);
+    },
+    // Add method to close log stream
+    close: () => {
+      logStream.end();
+    },
+  };
+
+  return logger;
+}
+
+export const logger = createSimpleLogger();

package/package.json

@@ -1,18 +1,21 @@
 {
   "name": "zed-ets-language-server",
-  "version": "1.1.1",
+  "version": "2.0.1",
   "description": "ETS language server wrapper for Zed ArkTS extension.",
   "type": "module",
   "main": "index.js",
   "engines": {
-    "node": ">=22"
+    "node": ">=22.12.0"
   },
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "test": "vitest run"
   },
   "author": "liuyanghejerry <liuyanghejerry@126.com>",
   "license": "MIT",
   "dependencies": {
     "@arkts/language-server": "^1.2.2"
+  },
+  "devDependencies": {
+    "vitest": "^4.0.9"
   }
 }

package/vitest.config.js

@@ -0,0 +1,8 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    environment: 'node',
+    globals: true,
+  },
+});