zed-ets-language-server 2.3.3 → 3.0.0

package/index.js

@@ -2,6 +2,8 @@
 
 import { spawn } from 'node:child_process';
 import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
 import { logger } from './lib/logger.js';
 import { parse } from './lib/data-parser.js';
 import { listHelperPaths } from './lib/lib-expander.js'
@@ -9,6 +11,40 @@ 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;
 
+// The extension installs ohos-typescript next to @arkts/language-server, so a
+// usable tsdk can be derived from the server path when settings don't name one:
+// <work dir>/node_modules/@arkts/language-server/bin/ets-language-server.js
+// <work dir>/node_modules/ohos-typescript/lib
+// @arkts/language-server v1.3+ refuses to initialize unless ets.sdkPath points at
+// a directory containing ets/build-tools/ets-loader/tsconfig.json (v1.2 accepted
+// any value). Provide a minimal skeleton so the server starts without a real SDK;
+// ArkUI typings degrade but TypeScript-level features keep working.
+function ensurePlaceholderSdk() {
+  const sdkDir = path.join(os.tmpdir(), 'zed-ets-empty-ohos-sdk');
+  const etsLoaderDir = path.join(sdkDir, 'ets', 'build-tools', 'ets-loader');
+  try {
+    fs.mkdirSync(path.join(etsLoaderDir, 'declarations'), { recursive: true });
+    fs.mkdirSync(path.join(sdkDir, 'ets', 'component'), { recursive: true });
+    const tsconfigPath = path.join(etsLoaderDir, 'tsconfig.json');
+    if (!fs.existsSync(tsconfigPath)) {
+      fs.writeFileSync(tsconfigPath, '{}\n');
+    }
+  } catch (error) {
+    logger.error(`Failed to prepare placeholder SDK dir ${sdkDir}: ${error.message}`);
+  }
+  return sdkDir;
+}
+
+function detectTsdk() {
+  if (!etsLangServerPath) return undefined;
+  const serverBinDir = path.dirname(etsLangServerPath);
+  const candidates = [
+    path.join(serverBinDir, '..', '..', '..', 'ohos-typescript', 'lib'),
+    path.join(serverBinDir, '..', 'node_modules', 'ohos-typescript', 'lib'),
+  ];
+  return candidates.find((dir) => fs.existsSync(path.join(dir, 'typescript.js')));
+}
+
 async function main() {
   logger.section('🚀 ETS Language Server Wrapper');
 
@@ -39,33 +75,71 @@ async function main() {
     logger.info(`Language server process exited, exit code: ${code}, signal: ${signal}`);
   });
 
+  // Requests injected by this wrapper (not sent by the editor); their responses
+  // must not be forwarded to the editor, which never issued them.
+  const wrapperRequestIds = new Set();
+
   // Set up forwarding of serverProcess IPC messages to process.stdout
   serverProcess.on('message', (message) => {
+    if (message?.id !== undefined && wrapperRequestIds.delete(message.id)) {
+      logger.info(`Swallowed response to wrapper-injected request ${message.id}: ${JSON.stringify(message.result ?? message.error)}`);
+      return;
+    }
     // Convert IPC message to standard LSP format and send to stdout
     const messageStr = JSON.stringify(message);
     const headers = `Content-Length: ${Buffer.byteLength(messageStr)}\r\n\r\n`;
     process.stdout.write(headers + messageStr);
   });
 
-  // Set up forwarding of process.stdin to serverProcess IPC
-  process.stdin.setEncoding('utf8');
+  // Set up forwarding of process.stdin to serverProcess IPC.
+  // No setEncoding here: the parser needs raw bytes because LSP Content-Length
+  // counts bytes, not characters.
   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;
+      message.params = message.params ?? {};
+      const initializationOptions = message.params.initializationOptions ?? {};
+      message.params.initializationOptions = initializationOptions;
+
+      // Zed only passes initializationOptions when the user configured
+      // lsp.arkts-language-server.initialization_options in settings. Fall back to
+      // env vars, then auto-detection, so the server starts out of the box.
+      if (!initializationOptions.tsdk) {
+        initializationOptions.tsdk = process.env.ZED_ETS_TSDK || process.env.TSDK || detectTsdk();
+        logger.info(`No tsdk in initializationOptions; falling back to: ${initializationOptions.tsdk}`);
+      }
+      if (!initializationOptions.ohosSdkPath) {
+        initializationOptions.ohosSdkPath = process.env.ZED_ETS_OHOS_SDK_PATH || process.env.OHOS_SDK_PATH;
+      }
+
+      // The server cannot finish `initialize` without a tsdk (it fails loading
+      // TypeScript and Zed reports "Failed to start language server").
+      if (!initializationOptions.tsdk) {
+        logger.error(`No tsdk in LSP settings, env (ZED_ETS_TSDK/TSDK), or next to ${etsLangServerPath}; forwarding initialize as-is, the server will likely fail to start.`);
+        serverProcess.send(message);
+        return;
+      }
+
+      if (!initializationOptions.ohosSdkPath) {
+        initializationOptions.ohosSdkPath = ensurePlaceholderSdk();
+        logger.error('No ohosSdkPath in LSP settings or env (ZED_ETS_OHOS_SDK_PATH/OHOS_SDK_PATH); using a placeholder SDK skeleton, ArkUI SDK types will be unavailable until lsp.arkts-language-server.initialization_options.ohosSdkPath is set in Zed settings.');
+      }
 
       const ohos = await listHelperPaths(initializationOptions.tsdk, initializationOptions.ohosSdkPath);
 
+      // Send both `ohos` and `ets` keys to stay compatible with
+      // @arkts/language-server v1.2.x (uses `ohos`) and v1.3.x+ (uses `ets`).
       const etsSpecialRequest = {
         jsonrpc: '2.0',
-        id: Date.now(),
+        id: `zed-ets-wrapper-${Date.now()}`,
         method: 'ets/waitForEtsConfigurationChangedRequested',
         params: {
           typescript: {
             tsdk: initializationOptions.tsdk,
           },
           ohos: ohos,
+          ets: ohos,
         },
       };
 
@@ -74,10 +148,12 @@ async function main() {
         tsdk: initializationOptions.tsdk,
       };
       generalInitRequest.params.initializationOptions.ohos = ohos;
+      generalInitRequest.params.initializationOptions.ets = ohos;
       
       logger.info(JSON.stringify(generalInitRequest));
       logger.info(JSON.stringify(etsSpecialRequest));
-      
+
+      wrapperRequestIds.add(etsSpecialRequest.id);
       serverProcess.send(generalInitRequest);
       serverProcess.send(etsSpecialRequest);
       return;

package/lib/data-parser.js

@@ -1,38 +1,43 @@
 import { logger } from './logger.js';
 
-let stdinBuffer = '';
+let stdinBuffer = Buffer.alloc(0);
 
 export function parse(data, callback) {
-  stdinBuffer += data.toString();
+  // LSP Content-Length is measured in bytes, not characters, so all parsing
+  // must operate on a Buffer. Convert string input to a Buffer if necessary
+  // (happens when stdin.setEncoding('utf8') is used, which yields strings).
+  const dataBuffer = Buffer.isBuffer(data) ? data : Buffer.from(data, 'utf8');
+  stdinBuffer = Buffer.concat([stdinBuffer, dataBuffer]);
 
   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 headerPart = stdinBuffer.subarray(0, headerEnd).toString('utf8');
+    const lengthMatch = headerPart.match(/Content-Length: (\d+)/);
+    if (!lengthMatch) break;
+
+    const contentLength = Number.parseInt(lengthMatch[1]);
     const messageStart = headerEnd + 4;
     const messageEnd = messageStart + contentLength;
 
+    // Content-Length counts bytes, so compare against the buffer's byte length.
     if (stdinBuffer.length < messageEnd) break;
 
-    // Extract message
-    const messageJson = stdinBuffer.substring(messageStart, messageEnd);
-    stdinBuffer = stdinBuffer.substring(messageEnd);
+    const messageJson = stdinBuffer.subarray(messageStart, messageEnd).toString('utf8');
+    stdinBuffer = stdinBuffer.subarray(messageEnd);
 
     try {
       const message = JSON.parse(messageJson);
       callback(message);
     } catch (error) {
       logger.error(`Error parsing message: ${error.message} ${error.stack} ${messageJson}`);
+      // Clear buffer on parse error to prevent corruption from leftover data
+      stdinBuffer = Buffer.alloc(0);
     }
   }
 }
 
 export function clearBuffer() {
-  stdinBuffer = '';
+  stdinBuffer = Buffer.alloc(0);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zed-ets-language-server",
-  "version": "2.3.3",
+  "version": "3.0.0",
   "description": "ETS language server wrapper for Zed ArkTS extension.",
   "type": "module",
   "main": "index.js",