zed-ets-language-server 2.3.4 → 3.1.0

package/index.js

@@ -2,13 +2,70 @@
 
 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'
+import { listHelperPaths } from './lib/lib-expander.js';
+import { resolveHmsSdkPath, resolveOhosSdkPath } from './lib/sdk-discovery.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;
+  // The extension installs ohos-typescript next to @arkts/language-server:
+  // <work dir>/node_modules/ohos-typescript/lib
+  // <work dir>/node_modules/@arkts/language-server/bin/ets-language-server.js
+  // Walk the ancestors of the server path and accept either layout so the
+  // detection also works for servers installed at other depths.
+  let dir = path.dirname(path.resolve(etsLangServerPath));
+  for (let depth = 0; depth < 8; depth++) {
+    for (const candidate of [
+      path.join(dir, 'ohos-typescript', 'lib'),
+      path.join(dir, 'node_modules', 'ohos-typescript', 'lib'),
+    ]) {
+      if (fs.existsSync(path.join(candidate, 'typescript.js'))) return candidate;
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return undefined;
+}
+
+// A usable tsdk must contain lib/typescript.js. The native TypeScript 7 line
+// ships no compiler API there, and settings inherited from another machine may
+// point at a half-installed directory; forwarding such a tsdk makes the server
+// hang inside `initialize` without ever answering.
+function isValidTsdk(dir) {
+  return Boolean(dir) && fs.existsSync(path.join(dir, 'typescript.js'));
+}
+
 async function main() {
   logger.section('🚀 ETS Language Server Wrapper');
 
@@ -39,29 +96,104 @@ 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}`);
+      }
+      // A native TypeScript installation may not contain the JS compiler API.
+      if (!isValidTsdk(initializationOptions.tsdk)) {
+        const fallbackTsdk = detectTsdk();
+        if (fallbackTsdk) {
+          logger.error(`tsdk ${initializationOptions.tsdk} has no lib/typescript.js; falling back to ${fallbackTsdk}`);
+          initializationOptions.tsdk = fallbackTsdk;
+        }
+      }
+
+      let hasRealOhosSdk = false;
+      try {
+        const resolvedSdk = resolveOhosSdkPath({
+          configuredPath: initializationOptions.ohosSdkPath,
+          env: process.env,
+        });
+        if (resolvedSdk) {
+          initializationOptions.ohosSdkPath = resolvedSdk.path;
+          hasRealOhosSdk = true;
+          logger.info(`Using HarmonyOS SDK from ${resolvedSdk.source}: ${resolvedSdk.path}`);
+        }
+      } catch (error) {
+        logger.error(error.message);
+        initializationOptions.ohosSdkPath = undefined;
+      }
 
-      const ohos = await listHelperPaths(initializationOptions.tsdk, initializationOptions.ohosSdkPath);
+      // 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;
+      }
 
-      // Send both `ohos` and `ets` keys to stay compatible with
-      // @arkts/language-server v1.2.x (uses `ohos`) and v1.3.x+ (uses `ets`).
+      if (!initializationOptions.ohosSdkPath) {
+        initializationOptions.ohosSdkPath = ensurePlaceholderSdk();
+        logger.error('No valid HarmonyOS SDK was found in LSP settings, environment variables, or standard DevEco Studio locations; using a placeholder SDK skeleton. ArkUI and @kit types will be unavailable until lsp.arkts-language-server.initialization_options.ohosSdkPath is set in Zed settings.');
+      }
+
+      try {
+        const resolvedHmsSdk = resolveHmsSdkPath({
+          configuredPath: initializationOptions.hmsSdkPath,
+          ohosSdkPath: hasRealOhosSdk ? initializationOptions.ohosSdkPath : undefined,
+          env: process.env,
+        });
+        if (resolvedHmsSdk) {
+          initializationOptions.hmsSdkPath = resolvedHmsSdk.path;
+          logger.info(`Using HMS SDK from ${resolvedHmsSdk.source}: ${resolvedHmsSdk.path}`);
+        }
+      } catch (error) {
+        logger.error(error.message);
+        initializationOptions.hmsSdkPath = undefined;
+      }
+
+      const ohos = await listHelperPaths(
+        initializationOptions.tsdk,
+        initializationOptions.ohosSdkPath,
+        initializationOptions.hmsSdkPath,
+      );
+
+      // Current servers read `ets`; retain the `ohos` alias for clients that
+      // still inspect the older configuration key.
       const etsSpecialRequest = {
         jsonrpc: '2.0',
-        id: Date.now(),
+        id: `zed-ets-wrapper-${Date.now()}`,
         method: 'ets/waitForEtsConfigurationChangedRequested',
         params: {
           typescript: {
@@ -81,7 +213,8 @@ async function main() {
       
       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/lib/lib-expander.js

@@ -73,22 +73,30 @@ export async function listLibs(dirPath) {
   return await getFilesByPattern(dirPath, /d\.ts$/i);
 }
 
-export async function listHelperPaths(tsDir, harmonyDir) {
+export async function listHelperPaths(tsDir, harmonyDir, hmsDir) {
   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'));
 
+  const modulePaths = ["./api/*", "./kits/*", "./arkts/*"];
+  if (hmsDir) {
+    modulePaths.push(path.join(hmsDir, 'ets', 'api', '*'));
+    modulePaths.push(path.join(hmsDir, 'ets', 'kits', '*'));
+  }
+
   return {
     sdkPath: harmonyDir,
+    hmsPath: hmsDir,
+    hmsSdkPath: hmsDir,
     etsComponentPath,
     etsLoaderConfigPath,
     etsLoaderPath,
     baseUrl: path.join(harmonyDir, '/ets'),
     lib: [...(await listLibs(tsDir)), ...(await listLibs(etsComponentPath)), ...etsLoaderLibs],
     "paths": {
-      "*": ["./api/*", "./kits/*", "./arkts/*"],
+      "*": modulePaths,
       "@internal/full/*": ["./api/@internal/full/*"]
     },
   };
-}
+}

package/lib/sdk-discovery.js

@@ -0,0 +1,182 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+const ENVIRONMENT_VARIABLES = [
+  'ZED_ETS_OHOS_SDK_PATH',
+  'OHOS_SDK_PATH',
+  'HARMONYOS_SDK_HOME',
+  'OPENHARMONY_SDK_HOME',
+  'DEVECO_SDK_HOME',
+];
+
+const REQUIRED_SDK_ENTRIES = [
+  { relativePath: path.join('ets', 'kits'), type: 'directory' },
+  { relativePath: path.join('ets', 'api'), type: 'directory' },
+  {
+    relativePath: path.join('ets', 'build-tools', 'ets-loader', 'tsconfig.json'),
+    type: 'file',
+  },
+];
+
+const REQUIRED_HMS_ENTRIES = [
+  { relativePath: path.join('ets', 'kits'), type: 'directory' },
+  { relativePath: path.join('ets', 'api'), type: 'directory' },
+];
+
+function hasRequiredEntries(candidate, entries) {
+  try {
+    return entries.every(({ relativePath, type }) => {
+      const entryPath = path.join(candidate, relativePath);
+      const stats = fs.statSync(entryPath);
+      const accessMode = type === 'directory'
+        ? fs.constants.R_OK | fs.constants.X_OK
+        : fs.constants.R_OK;
+      fs.accessSync(entryPath, accessMode);
+      return type === 'directory' ? stats.isDirectory() : stats.isFile();
+    });
+  } catch {
+    return false;
+  }
+}
+
+function isValidOhosSdkPath(candidate) {
+  return hasRequiredEntries(candidate, REQUIRED_SDK_ENTRIES);
+}
+
+function isValidHmsSdkPath(candidate) {
+  return hasRequiredEntries(candidate, REQUIRED_HMS_ENTRIES);
+}
+
+function expandHome(candidate, homeDirectory) {
+  return candidate.startsWith('~/')
+    ? path.join(homeDirectory, candidate.slice(2))
+    : candidate;
+}
+
+function normalizeCandidate(candidate, homeDirectory = os.homedir()) {
+  if (!candidate) return undefined;
+
+  const expanded = expandHome(candidate, homeDirectory);
+  const normalized = path.resolve(expanded);
+  const possibleRoots = [
+    normalized,
+    path.join(normalized, 'openharmony'),
+    path.join(normalized, 'default', 'openharmony'),
+  ];
+
+  try {
+    const versionDirectories = fs
+      .readdirSync(normalized, { withFileTypes: true })
+      .filter((entry) => entry.isDirectory() && entry.name !== 'default')
+      .map((entry) => entry.name)
+      .sort((left, right) => right.localeCompare(left, undefined, { numeric: true }));
+    for (const versionDirectory of versionDirectories) {
+      possibleRoots.push(path.join(normalized, versionDirectory, 'openharmony'));
+      possibleRoots.push(path.join(normalized, versionDirectory));
+    }
+  } catch {
+    // Missing or unreadable candidates are ignored during discovery.
+  }
+
+  return possibleRoots.find(isValidOhosSdkPath);
+}
+
+function defaultCandidates(platform, homeDirectory, env) {
+  const candidates = [];
+  const studioHome = env.DEVECO_STUDIO_HOME || env.DEVECO_HOME;
+  if (studioHome) {
+    candidates.push(path.join(studioHome, 'sdk'));
+    candidates.push(path.join(studioHome, 'Contents', 'sdk'));
+  }
+
+  if (platform === 'darwin') {
+    candidates.push(path.join(homeDirectory, 'Library', 'OpenHarmony', 'Sdk'));
+    candidates.push(path.join(homeDirectory, 'Library', 'Huawei', 'Sdk'));
+    candidates.push('/Applications/DevEco-Studio.app/Contents/sdk');
+    candidates.push(path.join(homeDirectory, 'Applications', 'DevEco-Studio.app', 'Contents', 'sdk'));
+  } else if (platform === 'win32') {
+    if (env.ProgramFiles) {
+      candidates.push(path.join(env.ProgramFiles, 'Huawei', 'DevEco Studio', 'sdk'));
+    }
+    if (env.LOCALAPPDATA) {
+      candidates.push(path.join(env.LOCALAPPDATA, 'Huawei', 'DevEcoStudio', 'sdk'));
+    }
+  } else {
+    candidates.push('/opt/DevEco-Studio/sdk');
+    candidates.push(path.join(homeDirectory, 'DevEco-Studio', 'sdk'));
+  }
+
+  return candidates;
+}
+
+export function resolveOhosSdkPath({
+  configuredPath,
+  env = process.env,
+  platform = process.platform,
+  homeDirectory = os.homedir(),
+  candidates,
+} = {}) {
+  if (configuredPath) {
+    const resolved = normalizeCandidate(configuredPath, homeDirectory);
+    if (!resolved) {
+      throw new Error(
+        `Invalid HarmonyOS SDK path: ${configuredPath}. Expected ets/kits, ets/api, and ets/build-tools/ets-loader/tsconfig.json.`,
+      );
+    }
+    return { path: resolved, source: 'settings' };
+  }
+
+  for (const variableName of ENVIRONMENT_VARIABLES) {
+    const resolved = normalizeCandidate(env[variableName], homeDirectory);
+    if (resolved) {
+      return { path: resolved, source: variableName };
+    }
+  }
+
+  const searchCandidates = candidates ?? defaultCandidates(platform, homeDirectory, env);
+  for (const candidate of searchCandidates) {
+    const resolved = normalizeCandidate(candidate, homeDirectory);
+    if (resolved) {
+      return { path: resolved, source: 'auto-detected' };
+    }
+  }
+
+  return undefined;
+}
+
+export function resolveHmsSdkPath({
+  configuredPath,
+  ohosSdkPath,
+  env = process.env,
+  homeDirectory = os.homedir(),
+} = {}) {
+  const candidates = configuredPath
+    ? [configuredPath, path.join(configuredPath, 'hms'), path.join(configuredPath, 'default', 'hms')]
+    : [
+        env.ZED_ETS_HMS_SDK_PATH,
+        env.HMS_SDK_PATH,
+        ohosSdkPath && path.join(path.dirname(ohosSdkPath), 'hms'),
+      ];
+
+  for (const candidate of candidates) {
+    if (!candidate) continue;
+    const normalized = path.resolve(expandHome(candidate, homeDirectory));
+    if (isValidHmsSdkPath(normalized)) {
+      return {
+        path: normalized,
+        source: configuredPath ? 'settings' : 'auto-detected',
+      };
+    }
+  }
+
+  if (configuredPath) {
+    throw new Error(
+      `Invalid HMS SDK path: ${configuredPath}. Expected ets/kits and ets/api.`,
+    );
+  }
+
+  return undefined;
+}
+
+export { isValidHmsSdkPath, isValidOhosSdkPath };