zed-ets-language-server 3.0.0 → 3.1.0

package/index.js

@@ -6,7 +6,8 @@ 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;
@@ -37,12 +38,32 @@ function ensurePlaceholderSdk() {
 
 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')));
+  // 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() {
@@ -109,8 +130,29 @@ async function main() {
         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;
+      // 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;
       }
 
       // The server cannot finish `initialize` without a tsdk (it fails loading
@@ -123,13 +165,32 @@ async function main() {
 
       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.');
+        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);
+      const ohos = await listHelperPaths(
+        initializationOptions.tsdk,
+        initializationOptions.ohosSdkPath,
+        initializationOptions.hmsSdkPath,
+      );
 
-      // Send both `ohos` and `ets` keys to stay compatible with
-      // @arkts/language-server v1.2.x (uses `ohos`) and v1.3.x+ (uses `ets`).
+      // Current servers read `ets`; retain the `ohos` alias for clients that
+      // still inspect the older configuration key.
       const etsSpecialRequest = {
         jsonrpc: '2.0',
         id: `zed-ets-wrapper-${Date.now()}`,

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 };

package/lib/sdk-discovery.test.js

@@ -0,0 +1,252 @@
+import { afterEach, describe, expect, it } from 'vitest';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { listHelperPaths } from './lib-expander.js';
+import { resolveHmsSdkPath, resolveOhosSdkPath } from './sdk-discovery.js';
+
+const temporaryDirectories = [];
+
+async function createSdkRoot(directory, relativePath) {
+  const sdkRoot = path.join(directory, relativePath);
+  await fs.mkdir(path.join(sdkRoot, 'ets', 'api'), { recursive: true });
+  await fs.mkdir(path.join(sdkRoot, 'ets', 'kits'), { recursive: true });
+  await fs.mkdir(path.join(sdkRoot, 'ets', 'component'), { recursive: true });
+  await fs.mkdir(path.join(sdkRoot, 'ets', 'build-tools', 'ets-loader', 'declarations'), {
+    recursive: true,
+  });
+  await fs.writeFile(
+    path.join(sdkRoot, 'ets', 'build-tools', 'ets-loader', 'tsconfig.json'),
+    '{}\n',
+  );
+  await fs.writeFile(
+    path.join(sdkRoot, 'ets', 'kits', '@kit.AbilityKit.d.ts'),
+    'export declare class UIAbility {}\n',
+  );
+
+  return sdkRoot;
+}
+
+async function createSdkFixture() {
+  const directory = await fs.mkdtemp(path.join(os.tmpdir(), 'zed-arkts-sdk-'));
+  temporaryDirectories.push(directory);
+  const sdkRoot = await createSdkRoot(directory, path.join('sdk', 'default', 'openharmony'));
+  return { directory, sdkRoot };
+}
+
+async function createHmsSdkRoot(ohosSdkRoot) {
+  const hmsSdkRoot = path.join(path.dirname(ohosSdkRoot), 'hms');
+  await fs.mkdir(path.join(hmsSdkRoot, 'ets', 'api'), { recursive: true });
+  await fs.mkdir(path.join(hmsSdkRoot, 'ets', 'kits'), { recursive: true });
+  await fs.writeFile(
+    path.join(hmsSdkRoot, 'ets', 'kits', '@kit.TestHmsKit.d.ts'),
+    'export declare const hmsApi: string;\n',
+  );
+  return hmsSdkRoot;
+}
+
+afterEach(async () => {
+  await Promise.all(
+    temporaryDirectories.splice(0).map((directory) =>
+      fs.rm(directory, { recursive: true, force: true }),
+    ),
+  );
+});
+
+describe('HarmonyOS SDK discovery', () => {
+  it('normalizes a DevEco SDK directory to its OpenHarmony root', async () => {
+    const { directory, sdkRoot } = await createSdkFixture();
+
+    const result = resolveOhosSdkPath({
+      configuredPath: path.join(directory, 'sdk', 'default'),
+      env: {},
+      candidates: [],
+    });
+
+    expect(result).toEqual({ path: sdkRoot, source: 'settings' });
+  });
+
+  it('prefers the explicitly configured SDK over environment values', async () => {
+    const configured = await createSdkFixture();
+    const fromEnvironment = await createSdkFixture();
+
+    const result = resolveOhosSdkPath({
+      configuredPath: configured.sdkRoot,
+      env: { ZED_ETS_OHOS_SDK_PATH: fromEnvironment.sdkRoot },
+      candidates: [],
+    });
+
+    expect(result).toEqual({ path: configured.sdkRoot, source: 'settings' });
+  });
+
+  it('expands a configured OpenHarmony SDK path relative to the supplied home', async () => {
+    const homeDirectory = await fs.mkdtemp(path.join(os.tmpdir(), 'zed-arkts-tilde-ohos-'));
+    temporaryDirectories.push(homeDirectory);
+    const sdkRoot = await createSdkRoot(
+      homeDirectory,
+      path.join('HarmonySdk', 'default', 'openharmony'),
+    );
+
+    const result = resolveOhosSdkPath({
+      configuredPath: '~/HarmonySdk',
+      env: {},
+      candidates: [],
+      homeDirectory,
+    });
+
+    expect(result).toEqual({ path: sdkRoot, source: 'settings' });
+  });
+
+  it('discovers the SDK bundled with DevEco Studio', async () => {
+    const { directory, sdkRoot } = await createSdkFixture();
+
+    const result = resolveOhosSdkPath({
+      env: {},
+      candidates: [path.join(directory, 'sdk')],
+    });
+
+    expect(result).toEqual({ path: sdkRoot, source: 'auto-detected' });
+  });
+
+  it.each([
+    ['OpenHarmony', path.join('Library', 'OpenHarmony', 'Sdk')],
+    ['Huawei', path.join('Library', 'Huawei', 'Sdk')],
+  ])('discovers the macOS %s user SDK directory', async (_vendor, sdkDirectory) => {
+    const homeDirectory = await fs.mkdtemp(path.join(os.tmpdir(), 'zed-arkts-home-sdk-'));
+    temporaryDirectories.push(homeDirectory);
+    const sdkRoot = await createSdkRoot(
+      homeDirectory,
+      path.join(sdkDirectory, 'default', 'openharmony'),
+    );
+
+    const result = resolveOhosSdkPath({
+      env: {},
+      platform: 'darwin',
+      homeDirectory,
+    });
+
+    expect(result).toEqual({ path: sdkRoot, source: 'auto-detected' });
+  });
+
+  it('selects the newest installed version when no default SDK exists', async () => {
+    const directory = await fs.mkdtemp(path.join(os.tmpdir(), 'zed-arkts-versioned-sdk-'));
+    temporaryDirectories.push(directory);
+    await createSdkRoot(directory, path.join('sdk', '12', 'openharmony'));
+    const newestSdk = await createSdkRoot(directory, path.join('sdk', '24', 'openharmony'));
+
+    const result = resolveOhosSdkPath({
+      env: {},
+      candidates: [path.join(directory, 'sdk')],
+    });
+
+    expect(result).toEqual({ path: newestSdk, source: 'auto-detected' });
+  });
+
+  it('rejects a path that does not contain ArkTS SDK declarations', async () => {
+    const directory = await fs.mkdtemp(path.join(os.tmpdir(), 'zed-arkts-invalid-sdk-'));
+    temporaryDirectories.push(directory);
+
+    expect(() =>
+      resolveOhosSdkPath({
+        configuredPath: directory,
+        env: {},
+        candidates: [],
+      }),
+    ).toThrow(/ets\/kits.*ets-loader\/tsconfig\.json/);
+  });
+
+  it('rejects SDK entries with the wrong file types', async () => {
+    const directory = await fs.mkdtemp(path.join(os.tmpdir(), 'zed-arkts-malformed-sdk-'));
+    temporaryDirectories.push(directory);
+    const sdkRoot = path.join(directory, 'openharmony');
+    await fs.mkdir(path.join(sdkRoot, 'ets', 'api'), { recursive: true });
+    await fs.writeFile(path.join(sdkRoot, 'ets', 'kits'), 'not a directory\n');
+    await fs.mkdir(path.join(sdkRoot, 'ets', 'build-tools', 'ets-loader', 'tsconfig.json'), {
+      recursive: true,
+    });
+
+    expect(() =>
+      resolveOhosSdkPath({ configuredPath: sdkRoot, env: {}, candidates: [] }),
+    ).toThrow(/Invalid HarmonyOS SDK path/);
+  });
+
+  it.runIf(process.platform !== 'win32')('rejects SDK directories that cannot be traversed', async () => {
+    const { sdkRoot } = await createSdkFixture();
+    const apiDirectory = path.join(sdkRoot, 'ets', 'api');
+    await fs.chmod(apiDirectory, 0o400);
+
+    expect(() =>
+      resolveOhosSdkPath({ configuredPath: sdkRoot, env: {}, candidates: [] }),
+    ).toThrow(/Invalid HarmonyOS SDK path/);
+  });
+
+  it('discovers a sibling HMS SDK and adds it to module resolution paths', async () => {
+    const { directory, sdkRoot } = await createSdkFixture();
+    const hmsSdkRoot = await createHmsSdkRoot(sdkRoot);
+    const tsdk = path.join(directory, 'typescript', 'lib');
+    await fs.mkdir(tsdk, { recursive: true });
+    await fs.writeFile(path.join(tsdk, 'lib.es5.d.ts'), 'interface Object {}\n');
+
+    const hmsResult = resolveHmsSdkPath({ ohosSdkPath: sdkRoot, env: {} });
+    const helperPaths = await listHelperPaths(tsdk, sdkRoot, hmsResult.path);
+
+    expect(hmsResult).toEqual({ path: hmsSdkRoot, source: 'auto-detected' });
+    expect(helperPaths.hmsSdkPath).toBe(hmsSdkRoot);
+    expect(helperPaths.paths['*']).toContain(path.join(hmsSdkRoot, 'ets', 'kits', '*'));
+    expect(helperPaths.paths['*']).toContain(path.join(hmsSdkRoot, 'ets', 'api', '*'));
+  });
+
+  it('expands a configured HMS SDK path relative to the supplied home', async () => {
+    const homeDirectory = await fs.mkdtemp(path.join(os.tmpdir(), 'zed-arkts-tilde-hms-'));
+    temporaryDirectories.push(homeDirectory);
+    const hmsSdkRoot = path.join(homeDirectory, 'HarmonySdk', 'default', 'hms');
+    await fs.mkdir(path.join(hmsSdkRoot, 'ets', 'api'), { recursive: true });
+    await fs.mkdir(path.join(hmsSdkRoot, 'ets', 'kits'), { recursive: true });
+
+    const result = resolveHmsSdkPath({
+      configuredPath: '~/HarmonySdk/default/hms',
+      env: {},
+      homeDirectory,
+    });
+
+    expect(result).toEqual({ path: hmsSdkRoot, source: 'settings' });
+  });
+
+  it('resolves OpenHarmony and HMS kit modules through the generated paths', async () => {
+    const typescriptModule = await import('ohos-typescript');
+    const ts = typescriptModule.default ?? typescriptModule;
+    const { directory, sdkRoot } = await createSdkFixture();
+    const hmsSdkRoot = await createHmsSdkRoot(sdkRoot);
+    const helperPaths = await listHelperPaths(
+      path.join(process.cwd(), 'node_modules', 'ohos-typescript', 'lib'),
+      sdkRoot,
+      hmsSdkRoot,
+    );
+    const compilerOptions = {
+      moduleResolution: ts.ModuleResolutionKind.NodeJs,
+      baseUrl: helperPaths.baseUrl,
+      paths: helperPaths.paths,
+    };
+    const containingFile = path.join(directory, 'entry', 'src', 'main', 'ets', 'Probe.ets');
+
+    const abilityKit = ts.resolveModuleName(
+      '@kit.AbilityKit',
+      containingFile,
+      compilerOptions,
+      ts.sys,
+    ).resolvedModule;
+    const hmsKit = ts.resolveModuleName(
+      '@kit.TestHmsKit',
+      containingFile,
+      compilerOptions,
+      ts.sys,
+    ).resolvedModule;
+
+    expect(abilityKit?.resolvedFileName).toBe(
+      path.join(sdkRoot, 'ets', 'kits', '@kit.AbilityKit.d.ts'),
+    );
+    expect(hmsKit?.resolvedFileName).toBe(
+      path.join(hmsSdkRoot, 'ets', 'kits', '@kit.TestHmsKit.d.ts'),
+    );
+  });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zed-ets-language-server",
-  "version": "3.0.0",
+  "version": "3.1.0",
   "description": "ETS language server wrapper for Zed ArkTS extension.",
   "type": "module",
   "main": "index.js",
@@ -17,9 +17,9 @@
   "author": "liuyanghejerry <liuyanghejerry@126.com>",
   "license": "MIT",
   "dependencies": {
-    "@arkts/language-server": "^1.2.8"
+    "@arkts/language-server": "^1.3.10"
   },
   "devDependencies": {
-    "vitest": "^4.0.9"
+    "vitest": "^4.1.11"
   }
 }

package/tests/integration/kit-diagnostics.test.js

@@ -0,0 +1,232 @@
+import { afterAll, beforeAll, describe, expect, it } from 'vitest';
+import { spawn } from 'node:child_process';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+
+const testDirectory = path.dirname(fileURLToPath(import.meta.url));
+let fixtureDirectory;
+let projectDirectory;
+let sourcePath;
+let serverProcess;
+let languageServerVersion;
+let stdoutBuffer = Buffer.alloc(0);
+const messages = [];
+const waiters = [];
+
+function send(message) {
+  const body = Buffer.from(JSON.stringify(message));
+  serverProcess.stdin.write(
+    Buffer.concat([Buffer.from(`Content-Length: ${body.length}\r\n\r\n`), body]),
+  );
+}
+
+function dispatch(message) {
+  messages.push(message);
+
+  if (message.method && message.id !== undefined) {
+    let result = null;
+    if (message.method === 'workspace/configuration') {
+      result = (message.params?.items ?? []).map(() => null);
+    } else if (message.method === 'workspace/workspaceFolders') {
+      result = [{ uri: pathToFileURL(projectDirectory).href, name: 'project' }];
+    }
+    send({ jsonrpc: '2.0', id: message.id, result });
+  }
+
+  for (let index = waiters.length - 1; index >= 0; index -= 1) {
+    if (!waiters[index].predicate(message)) continue;
+    const [waiter] = waiters.splice(index, 1);
+    clearTimeout(waiter.timer);
+    waiter.resolve(message);
+  }
+}
+
+function collectMessages(chunk) {
+  stdoutBuffer = Buffer.concat([stdoutBuffer, chunk]);
+  while (true) {
+    const headerEnd = stdoutBuffer.indexOf('\r\n\r\n');
+    if (headerEnd === -1) return;
+    const header = stdoutBuffer.subarray(0, headerEnd).toString('ascii');
+    const lengthMatch = header.match(/Content-Length:\s*(\d+)/i);
+    if (!lengthMatch) throw new Error('LSP response is missing Content-Length');
+    const bodyLength = Number(lengthMatch[1]);
+    const bodyStart = headerEnd + 4;
+    if (stdoutBuffer.length < bodyStart + bodyLength) return;
+    const body = stdoutBuffer.subarray(bodyStart, bodyStart + bodyLength);
+    stdoutBuffer = stdoutBuffer.subarray(bodyStart + bodyLength);
+    dispatch(JSON.parse(body.toString('utf8')));
+  }
+}
+
+function waitForMessage(predicate, timeout = 30000) {
+  const existing = messages.find(predicate);
+  if (existing) return Promise.resolve(existing);
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => reject(new Error('Timed out waiting for LSP message')), timeout);
+    waiters.push({ predicate, resolve, timer });
+  });
+}
+
+beforeAll(async () => {
+  fixtureDirectory = await fs.mkdtemp(path.join(os.tmpdir(), 'zed-arkts-real-lsp-'));
+  projectDirectory = path.join(fixtureDirectory, 'project');
+  const sdkDirectory = path.join(fixtureDirectory, 'studio', 'Contents', 'sdk', 'default');
+  const ohosSdk = path.join(sdkDirectory, 'openharmony');
+  const hmsSdk = path.join(sdkDirectory, 'hms');
+  sourcePath = path.join(projectDirectory, 'entry', 'src', 'main', 'ets', 'Probe.ets');
+
+  await Promise.all([
+    fs.mkdir(path.dirname(sourcePath), { recursive: true }),
+    fs.mkdir(path.join(ohosSdk, 'ets', 'api'), { recursive: true }),
+    fs.mkdir(path.join(ohosSdk, 'ets', 'kits'), { recursive: true }),
+    fs.mkdir(path.join(ohosSdk, 'ets', 'component'), { recursive: true }),
+    fs.mkdir(path.join(ohosSdk, 'ets', 'build-tools', 'ets-loader', 'declarations'), {
+      recursive: true,
+    }),
+    fs.mkdir(path.join(hmsSdk, 'ets', 'api'), { recursive: true }),
+    fs.mkdir(path.join(hmsSdk, 'ets', 'kits'), { recursive: true }),
+  ]);
+  await Promise.all([
+    fs.writeFile(path.join(ohosSdk, 'ets', 'build-tools', 'ets-loader', 'tsconfig.json'), '{}\n'),
+    fs.writeFile(
+      path.join(ohosSdk, 'ets', 'kits', '@kit.AbilityKit.d.ts'),
+      'export declare class UIAbility {}\n',
+    ),
+    fs.writeFile(
+      path.join(hmsSdk, 'ets', 'kits', '@kit.TestHmsKit.d.ts'),
+      'export declare const hmsApi: string;\n',
+    ),
+    fs.writeFile(
+      path.join(projectDirectory, 'build-profile.json5'),
+      '{ app: { products: [{ name: "default" }] }, modules: [{ name: "entry", srcPath: "./entry" }] }\n',
+    ),
+    fs.writeFile(
+      path.join(projectDirectory, 'oh-package.json5'),
+      '{ name: "probe", version: "1.0.0" }\n',
+    ),
+    fs.writeFile(
+      path.join(projectDirectory, 'entry', 'build-profile.json5'),
+      '{ apiType: "stageMode", buildOption: {} }\n',
+    ),
+    fs.writeFile(
+      sourcePath,
+      "import { UIAbility } from '@kit.AbilityKit';\n" +
+        "import { hmsApi } from '@kit.TestHmsKit';\n" +
+        "import { missingApi } from '@kit.DoesNotExist';\n" +
+        'export const probe: UIAbility | string = hmsApi;\n' +
+        'export const missingProbe = missingApi;\n',
+    ),
+  ]);
+
+  const wrapperPath = path.join(testDirectory, '..', '..', 'index.js');
+  const languageServerPath = path.join(
+    testDirectory,
+    '..',
+    '..',
+    'node_modules',
+    '@arkts',
+    'language-server',
+    'bin',
+    'ets-language-server.js',
+  );
+  const languageServerPackage = JSON.parse(
+    await fs.readFile(
+      path.join(testDirectory, '..', '..', 'node_modules', '@arkts', 'language-server', 'package.json'),
+      'utf8',
+    ),
+  );
+  languageServerVersion = languageServerPackage.version;
+  const env = { ...process.env };
+  for (const variableName of [
+    'ZED_ETS_OHOS_SDK_PATH',
+    'OHOS_SDK_PATH',
+    'HARMONYOS_SDK_HOME',
+    'OPENHARMONY_SDK_HOME',
+    'DEVECO_SDK_HOME',
+    'ZED_ETS_HMS_SDK_PATH',
+    'HMS_SDK_PATH',
+    'ZED_ETS_TSDK',
+    'TSDK',
+  ]) {
+    delete env[variableName];
+  }
+  Object.assign(env, {
+    ETS_LANG_SERVER: languageServerPath,
+    DEVECO_STUDIO_HOME: path.join(fixtureDirectory, 'studio'),
+  });
+  serverProcess = spawn(process.execPath, [wrapperPath], {
+    cwd: projectDirectory,
+    env,
+    stdio: ['pipe', 'pipe', 'pipe'],
+  });
+  serverProcess.stdout.on('data', collectMessages);
+});
+
+afterAll(async () => {
+  if (serverProcess && serverProcess.exitCode === null) {
+    await new Promise((resolve) => {
+      const timeout = setTimeout(() => serverProcess.kill('SIGKILL'), 5000);
+      serverProcess.once('exit', () => {
+        clearTimeout(timeout);
+        resolve();
+      });
+      serverProcess.kill();
+    });
+  }
+  await fs.rm(fixtureDirectory, { recursive: true, force: true });
+});
+
+describe('real ArkTS language server Kit diagnostics', () => {
+  it('resolves OpenHarmony and HMS Kit modules with language server 1.3.x', async () => {
+    expect(languageServerVersion).toMatch(/^1\.3\./);
+    const rootUri = pathToFileURL(projectDirectory).href;
+    send({
+      jsonrpc: '2.0',
+      id: 1,
+      method: 'initialize',
+      params: {
+        processId: process.pid,
+        rootUri,
+        workspaceFolders: [{ uri: rootUri, name: 'project' }],
+        capabilities: {
+          workspace: { configuration: true, workspaceFolders: true },
+          textDocument: { publishDiagnostics: {} },
+        },
+        initializationOptions: {},
+      },
+    });
+    const initializeResponse = await waitForMessage((message) => message.id === 1);
+    expect(initializeResponse.error).toBeUndefined();
+    send({ jsonrpc: '2.0', method: 'initialized', params: {} });
+
+    const uri = pathToFileURL(sourcePath).href;
+    send({
+      jsonrpc: '2.0',
+      method: 'textDocument/didOpen',
+      params: {
+        textDocument: {
+          uri,
+          languageId: 'ets',
+          version: 1,
+          text: await fs.readFile(sourcePath, 'utf8'),
+        },
+      },
+    });
+    const diagnostics = await waitForMessage(
+      (message) =>
+        message.method === 'textDocument/publishDiagnostics' &&
+        message.params.uri === uri &&
+        message.params.diagnostics.some((diagnostic) => Number(diagnostic.code) === 2307),
+    );
+
+    const unresolvedModules = diagnostics.params.diagnostics.filter(
+      (diagnostic) => Number(diagnostic.code) === 2307,
+    );
+    expect(unresolvedModules).toHaveLength(1);
+    expect(unresolvedModules[0].message).toContain('@kit.DoesNotExist');
+    expect(unresolvedModules[0].message).not.toContain('@kit.AbilityKit');
+    expect(unresolvedModules[0].message).not.toContain('@kit.TestHmsKit');
+  }, 40000);
+});

package/tests/integration/lsp-server.test.js

@@ -1,18 +1,36 @@
 import { describe, it, expect, beforeAll, afterAll } from 'vitest';
 import { spawn } from 'child_process';
+import { mkdtempSync } from 'fs';
+import { tmpdir } from 'os';
 import { fileURLToPath } from 'url';
 import { dirname, join } from 'path';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 
+const serverPath = join(__dirname, '../../index.js');
+const mockServerPath = join(__dirname, '../mocks/mock-ets-server.js');
+const bundledTsdk = join(__dirname, '../../node_modules/ohos-typescript/lib');
+
+// Hermetic env: never inherit ambient tsdk/sdk settings from the shell.
+function baseEnv(overrides = {}) {
+  return {
+    ...process.env,
+    ETS_LANG_SERVER: mockServerPath,
+    TSDK: '',
+    ZED_ETS_TSDK: '',
+    OHOS_SDK_PATH: '',
+    ZED_ETS_OHOS_SDK_PATH: '',
+    ...overrides,
+  };
+}
+
 /**
  * 创建 LSP 消息
  */
 function createLSPMessage(content) {
-  const json = JSON.stringify(content);
-  const contentLength = Buffer.byteLength(json, 'utf8');
-  return `Content-Length: ${contentLength}\r\n\r\n${json}`;
+  const contentLength = Buffer.byteLength(JSON.stringify(content));
+  return `Content-Length: ${contentLength}\r\n\r\n${JSON.stringify(content)}`;
 }
 
 /**
@@ -22,7 +40,7 @@ function parseLSPResponse(data) {
   const text = data.toString();
   const match = text.match(/Content-Length: (\d+)\r\n\r\n(.*)/s);
   if (!match) return null;
-  
+
   try {
     return JSON.parse(match[2]);
   } catch (e) {
@@ -30,28 +48,77 @@ function parseLSPResponse(data) {
   }
 }
 
+/**
+ * 等待特定响应
+ */
+function waitForResponse(responses, predicate, timeout = 2000) {
+  return new Promise((resolve, reject) => {
+    const startTime = Date.now();
+    const checkInterval = setInterval(() => {
+      const response = responses.find(predicate);
+      if (response) {
+        clearInterval(checkInterval);
+        resolve(response);
+      } else if (Date.now() - startTime > timeout) {
+        clearInterval(checkInterval);
+        reject(new Error('Timeout waiting for response'));
+      }
+    }, 50);
+  });
+}
+
+function startWrapper(env) {
+  const serverProcess = spawn('node', [serverPath], {
+    stdio: ['pipe', 'pipe', 'pipe'],
+    env,
+  });
+
+  const responses = [];
+  let stdoutBuffer = Buffer.alloc(0);
+  serverProcess.stdout.on('data', (data) => {
+    stdoutBuffer = Buffer.concat([stdoutBuffer, data]);
+    // SDK discovery can make initialize responses span multiple pipe chunks.
+    while (true) {
+      const headerEnd = stdoutBuffer.indexOf('\r\n\r\n');
+      if (headerEnd < 0) return;
+      const header = stdoutBuffer.subarray(0, headerEnd).toString('ascii');
+      const lengthMatch = header.match(/Content-Length:\s*(\d+)/i);
+      if (!lengthMatch) throw new Error('Invalid LSP response header');
+      const bodyStart = headerEnd + 4;
+      const bodyEnd = bodyStart + Number(lengthMatch[1]);
+      if (stdoutBuffer.length < bodyEnd) return;
+      responses.push(JSON.parse(stdoutBuffer.subarray(bodyStart, bodyEnd).toString('utf8')));
+      stdoutBuffer = stdoutBuffer.subarray(bodyEnd);
+    }
+  });
+
+  serverProcess.stderr.on('data', (data) => {
+    console.error(`LSP Server Error: ${data}`);
+  });
+
+  return { serverProcess, responses };
+}
+
+function initializeMessage(id) {
+  return createLSPMessage({
+    jsonrpc: '2.0',
+    id,
+    method: 'initialize',
+    params: {
+      processId: null,
+      rootUri: null,
+      capabilities: {},
+    },
+  });
+}
+
 describe('LSP Server Integration Tests', () => {
   let serverProcess;
   let responses = [];
+  let messageId = 1;
 
   beforeAll(() => {
-    // 启动 LSP 服务器
-    const serverPath = join(__dirname, '../../index.js');
-    serverProcess = spawn('node', [serverPath], {
-      stdio: ['pipe', 'pipe', 'pipe']
-    });
-
-    // 收集响应
-    serverProcess.stdout.on('data', (data) => {
-      const response = parseLSPResponse(data);
-      if (response) {
-        responses.push(response);
-      }
-    });
-
-    serverProcess.stderr.on('data', (data) => {
-      console.error(`LSP Server Error: ${data}`);
-    });
+    ({ serverProcess, responses } = startWrapper(baseEnv()));
   });
 
   afterAll(() => {
@@ -60,65 +127,78 @@ describe('LSP Server Integration Tests', () => {
     }
   });
 
-  it('should respond to initialize request', (done) => {
-    const initRequest = {
-      jsonrpc: '2.0',
-      id: 1,
-      method: 'initialize',
-      params: {
-        processId: process.pid,
-        rootUri: null,
-        capabilities: {}
-      }
-    };
+  it('should respond to initialize request', async () => {
+    serverProcess.stdin.write(initializeMessage(messageId));
+    const initResponse = await waitForResponse(responses, (r) => r.id === messageId);
+    messageId++;
+
+    expect(initResponse.result).toBeDefined();
+    expect(initResponse.result.capabilities).toBeDefined();
+  });
 
-    const message = createLSPMessage(initRequest);
-    serverProcess.stdin.write(message);
-
-    // 等待响应
-    setTimeout(() => {
-      const initResponse = responses.find(r => r.id === 1);
-      expect(initResponse).toBeDefined();
-      expect(initResponse.result).toBeDefined();
-      expect(initResponse.result.capabilities).toBeDefined();
-      done();
-    }, 1000);
+  it('should auto-detect the bundled tsdk when none is configured', async () => {
+    serverProcess.stdin.write(initializeMessage(messageId));
+    const initResponse = await waitForResponse(responses, (r) => r.id === messageId);
+    messageId++;
+
+    expect(initResponse.result.initializationOptions.typescript.tsdk).toBe(bundledTsdk);
   });
 
-  it('should accept initialized notification', (done) => {
-    const initializedNotif = {
+  it('should accept initialized notification', async () => {
+    serverProcess.stdin.write(createLSPMessage({
       jsonrpc: '2.0',
       method: 'initialized',
-      params: {}
-    };
-
-    const message = createLSPMessage(initializedNotif);
-    serverProcess.stdin.write(message);
+      params: {},
+    }));
 
     // 通知不需要响应，只需确保不崩溃
-    setTimeout(() => {
-      expect(serverProcess.killed).toBe(false);
-      done();
-    }, 500);
+    await new Promise((resolve) => setTimeout(resolve, 300));
+    expect(serverProcess.exitCode).toBeNull();
   });
 
-  it('should handle shutdown request', (done) => {
-    const shutdownRequest = {
+  it('should handle shutdown request', async () => {
+    serverProcess.stdin.write(createLSPMessage({
       jsonrpc: '2.0',
       id: 99,
       method: 'shutdown',
-      params: null
-    };
+      params: null,
+    }));
+
+    const shutdownResponse = await waitForResponse(responses, (r) => r.id === 99);
+    // 某些 LSP 服务器可能返回 null result
+    expect(shutdownResponse).toBeDefined();
+  });
+});
+
+describe('LSP tsdk fallback', () => {
+  // A tsdk without lib/typescript.js (e.g. the native TypeScript 7 line)
+  // used to hang the real server inside initialize. The wrapper must
+  // substitute the bundled ohos-typescript instead of forwarding it.
+  it('substitutes a broken TSDK env value with the bundled ohos-typescript', async () => {
+    const brokenTsdkDir = mkdtempSync(join(tmpdir(), 'zed-ets-broken-tsdk-'));
+    const { serverProcess, responses } = startWrapper(baseEnv({ TSDK: brokenTsdkDir }));
+
+    try {
+      serverProcess.stdin.write(initializeMessage(1));
+      const initResponse = await waitForResponse(responses, (r) => r.id === 1);
+
+      expect(initResponse.result.initializationOptions.typescript.tsdk).toBe(bundledTsdk);
+    } finally {
+      serverProcess.kill();
+    }
+  });
+
+  it('forwards a valid TSDK unchanged', async () => {
+    const { serverProcess, responses } = startWrapper(baseEnv({ TSDK: bundledTsdk }));
 
-    const message = createLSPMessage(shutdownRequest);
-    serverProcess.stdin.write(message);
+    try {
+      serverProcess.stdin.write(initializeMessage(1));
+      const initResponse = await waitForResponse(responses, (r) => r.id === 1);
 
-    setTimeout(() => {
-      const shutdownResponse = responses.find(r => r.id === 99);
-      // 某些 LSP 服务器可能返回 null result
-      expect(shutdownResponse).toBeDefined();
-      done();
-    }, 1000);
+      expect(initResponse.result.initializationOptions.typescript.tsdk).toBe(bundledTsdk);
+    } finally {
+      serverProcess.kill();
+    }
   });
 });
 
@@ -126,7 +206,7 @@ describe('LSP Message Protocol', () => {
   it('should format messages correctly', () => {
     const content = { jsonrpc: '2.0', method: 'test' };
     const message = createLSPMessage(content);
-    
+
     expect(message).toContain('Content-Length:');
     expect(message).toContain('\r\n\r\n');
     expect(message).toContain(JSON.stringify(content));
@@ -140,7 +220,7 @@ describe('LSP Message Protocol', () => {
     };
     const data = createLSPMessage(mockResponse);
     const parsed = parseLSPResponse(Buffer.from(data));
-    
+
     expect(parsed).toEqual(mockResponse);
   });
 });

package/tests/integration/sdk-initialization.test.js

@@ -0,0 +1,167 @@
+import { afterAll, beforeAll, describe, expect, it } from 'vitest';
+import { spawn } from 'node:child_process';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const testDirectory = path.dirname(fileURLToPath(import.meta.url));
+let fixtureDirectory;
+let sdkRoot;
+let hmsSdkRoot;
+let serverProcess;
+let stdoutBuffer = Buffer.alloc(0);
+const responses = [];
+
+function encodeLspMessage(message) {
+  const body = Buffer.from(JSON.stringify(message));
+  return Buffer.concat([
+    Buffer.from(`Content-Length: ${body.length}\r\n\r\n`),
+    body,
+  ]);
+}
+
+function collectLspMessages(chunk) {
+  stdoutBuffer = Buffer.concat([stdoutBuffer, chunk]);
+
+  while (true) {
+    const headerEnd = stdoutBuffer.indexOf('\r\n\r\n');
+    if (headerEnd === -1) return;
+
+    const header = stdoutBuffer.subarray(0, headerEnd).toString('ascii');
+    const lengthMatch = header.match(/Content-Length:\s*(\d+)/i);
+    if (!lengthMatch) return;
+
+    const bodyStart = headerEnd + 4;
+    const bodyLength = Number(lengthMatch[1]);
+    if (stdoutBuffer.length < bodyStart + bodyLength) return;
+
+    const body = stdoutBuffer.subarray(bodyStart, bodyStart + bodyLength);
+    responses.push(JSON.parse(body.toString('utf8')));
+    stdoutBuffer = stdoutBuffer.subarray(bodyStart + bodyLength);
+  }
+}
+
+async function waitForResponse(predicate, timeout = 3000) {
+  const deadline = Date.now() + timeout;
+  while (Date.now() < deadline) {
+    const response = responses.find(predicate);
+    if (response) return response;
+    await new Promise((resolve) => setTimeout(resolve, 25));
+  }
+  throw new Error('Timed out waiting for LSP response');
+}
+
+beforeAll(async () => {
+  fixtureDirectory = await fs.mkdtemp(path.join(os.tmpdir(), 'zed-arkts-deveco-'));
+  sdkRoot = path.join(fixtureDirectory, 'Contents', 'sdk', 'default', 'openharmony');
+  await fs.mkdir(path.join(sdkRoot, 'ets', 'api'), { recursive: true });
+  await fs.mkdir(path.join(sdkRoot, 'ets', 'kits'), { recursive: true });
+  await fs.mkdir(path.join(sdkRoot, 'ets', 'component'), { recursive: true });
+  await fs.mkdir(path.join(sdkRoot, 'ets', 'build-tools', 'ets-loader', 'declarations'), {
+    recursive: true,
+  });
+  await fs.writeFile(
+    path.join(sdkRoot, 'ets', 'build-tools', 'ets-loader', 'tsconfig.json'),
+    '{}\n',
+  );
+  await fs.writeFile(
+    path.join(sdkRoot, 'ets', 'kits', '@kit.AbilityKit.d.ts'),
+    'export declare class UIAbility {}\n',
+  );
+  hmsSdkRoot = path.join(fixtureDirectory, 'Contents', 'sdk', 'default', 'hms');
+  await fs.mkdir(path.join(hmsSdkRoot, 'ets', 'api'), { recursive: true });
+  await fs.mkdir(path.join(hmsSdkRoot, 'ets', 'kits'), { recursive: true });
+  await fs.writeFile(
+    path.join(hmsSdkRoot, 'ets', 'kits', '@kit.TestHmsKit.d.ts'),
+    'export declare const hmsApi: string;\n',
+  );
+  const placeholderSiblingHms = path.join(fixtureDirectory, 'hms');
+  await fs.mkdir(path.join(placeholderSiblingHms, 'ets', 'api'), { recursive: true });
+  await fs.mkdir(path.join(placeholderSiblingHms, 'ets', 'kits'), { recursive: true });
+
+  const wrapperPath = path.join(testDirectory, '..', '..', 'index.js');
+  const mockServerPath = path.join(testDirectory, '..', 'mocks', 'mock-ets-server.js');
+  const tsdk = path.join(testDirectory, '..', '..', 'node_modules', 'ohos-typescript', 'lib');
+  const env = { ...process.env };
+  delete env.ZED_ETS_OHOS_SDK_PATH;
+  delete env.OHOS_SDK_PATH;
+  delete env.HARMONYOS_SDK_HOME;
+  delete env.OPENHARMONY_SDK_HOME;
+  delete env.DEVECO_SDK_HOME;
+  delete env.ZED_ETS_HMS_SDK_PATH;
+  delete env.HMS_SDK_PATH;
+  Object.assign(env, {
+    ETS_LANG_SERVER: mockServerPath,
+    ZED_ETS_TSDK: tsdk,
+    DEVECO_STUDIO_HOME: fixtureDirectory,
+    TMPDIR: fixtureDirectory,
+  });
+
+  serverProcess = spawn(process.execPath, [wrapperPath], {
+    env,
+    stdio: ['pipe', 'pipe', 'pipe'],
+  });
+  serverProcess.stdout.on('data', collectLspMessages);
+});
+
+afterAll(async () => {
+  serverProcess?.kill();
+  await fs.rm(fixtureDirectory, { recursive: true, force: true });
+});
+
+describe('SDK initialization', () => {
+  it('injects the DevEco OpenHarmony SDK into ArkTS initialization', async () => {
+    serverProcess.stdin.write(
+      encodeLspMessage({
+        jsonrpc: '2.0',
+        id: 1,
+        method: 'initialize',
+        params: {
+          processId: process.pid,
+          rootUri: 'file:///tmp/harmony-project',
+          capabilities: {},
+          initializationOptions: {},
+        },
+      }),
+    );
+
+    const response = await waitForResponse((message) => message.id === 1);
+    const initializationOptions = response.result.initializationOptions;
+
+    expect(initializationOptions.ohos.sdkPath).toBe(sdkRoot);
+    expect(initializationOptions.ets.sdkPath).toBe(sdkRoot);
+    expect(initializationOptions.ohos.baseUrl).toBe(path.join(sdkRoot, 'ets'));
+    expect(initializationOptions.ets.hmsPath).toBe(hmsSdkRoot);
+    expect(initializationOptions.ohos.hmsSdkPath).toBe(hmsSdkRoot);
+    expect(initializationOptions.ohos.paths['*']).toContain(
+      path.join(hmsSdkRoot, 'ets', 'kits', '*'),
+    );
+  });
+
+  it('does not infer an HMS SDK from the placeholder OpenHarmony SDK', async () => {
+    serverProcess.stdin.write(
+      encodeLspMessage({
+        jsonrpc: '2.0',
+        id: 2,
+        method: 'initialize',
+        params: {
+          processId: process.pid,
+          rootUri: 'file:///tmp/harmony-project',
+          capabilities: {},
+          initializationOptions: {
+            ohosSdkPath: path.join(fixtureDirectory, 'invalid-openharmony'),
+          },
+        },
+      }),
+    );
+
+    const response = await waitForResponse((message) => message.id === 2);
+    const initializationOptions = response.result.initializationOptions;
+
+    expect(initializationOptions.ets.sdkPath).toBe(
+      path.join(fixtureDirectory, 'zed-ets-empty-ohos-sdk'),
+    );
+    expect(initializationOptions.ets.hmsPath).toBeUndefined();
+  });
+});

package/tests/mocks/mock-ets-server.js

@@ -91,10 +91,12 @@ struct Test {
           textDocumentSync: 1,
           documentFormattingProvider: true,
           documentRangeFormattingProvider: true
-        }
+        },
+        // Echo what the wrapper forwarded so tests can assert on it.
+        initializationOptions: message.params?.initializationOptions ?? {}
       }
     };
-    
+
     process.send(response);
   }