@duckmind/dm-linux-x64 0.63.9 → 0.64.2

package/extensions/dm-lens/clients/lsp/launch.js

@@ -0,0 +1,469 @@
+import {
+  execFileSync,
+  spawn as nodeSpawn
+} from "node:child_process";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { isTestMode } from "../env-utils.js";
+import { getGlobalDmLensDir } from "../file-utils.js";
+import { getGlobalDmLensLogDir } from "../probe-home-state.js";
+import { isFullyQualified } from "../path-utils.js";
+import { findGlobalBinary } from "../package-manager.js";
+import { redactSecrets } from "../redact/secrets.js";
+import { classifySpawnFailure, SpawnFailureError } from "../safe-spawn.js";
+import { getRubyVersionDirNamesAsync } from "./ruby-drive-dirs.js";
+const isWindows = process.platform === "win32";
+function computeNeedsShell(resolvedCommand) {
+  return isWindows && (resolvedCommand.includes(" ") || /\.(cmd|bat)$/i.test(resolvedCommand) || !/\.(exe|cmd|bat)$/i.test(resolvedCommand));
+}
+const DEFAULT_STARTUP_FAILURE_WINDOW_MS = 50;
+const WINDOWS_NAV_STARTUP_FAILURE_WINDOW_MS = 500;
+const SESSIONSTART_LOG_DIR = getGlobalDmLensLogDir();
+const SESSIONSTART_LOG = path.join(SESSIONSTART_LOG_DIR, "sessionstart.log");
+const DM_LENS_BIN_DIR = path.join(getGlobalDmLensDir(), "bin");
+const DM_LENS_TOOLS_BIN_DIR = path.join(getGlobalDmLensDir(), "tools", "node_modules", ".bin");
+function logSessionStart(msg) {
+  if (isTestMode()) {
+    return;
+  }
+  const line = redactSecrets(`[${new Date().toISOString()}] ${msg}
+`);
+  try {
+    fs.mkdirSync(SESSIONSTART_LOG_DIR, { recursive: true });
+    fs.appendFileSync(SESSIONSTART_LOG, line);
+  } catch {}
+}
+function compactLogValue(value, max = 280) {
+  const normalized = value.replace(/\s+/g, " ").trim();
+  if (!normalized)
+    return "";
+  return normalized.length > max ? `${normalized.slice(0, max)}...` : normalized;
+}
+function delimiterForPlatform(platform) {
+  return platform === "win32" ? ";" : ":";
+}
+function splitPathEntries(value, delimiter) {
+  if (!value)
+    return [];
+  return value.split(delimiter).map((entry) => entry.trim()).filter((entry) => entry.length > 0);
+}
+function normalizePathEntry(entry, platform) {
+  const normalized = path.normalize(entry);
+  return platform === "win32" ? normalized.toLowerCase() : normalized;
+}
+export function combinePathValuesForPlatform(values, platform = process.platform) {
+  const unique = [];
+  const seen = new Set;
+  const delimiter = delimiterForPlatform(platform);
+  for (const value of values) {
+    for (const entry of splitPathEntries(value, delimiter)) {
+      const key = normalizePathEntry(entry, platform);
+      if (seen.has(key))
+        continue;
+      seen.add(key);
+      unique.push(entry);
+    }
+  }
+  return unique.join(delimiter);
+}
+function resolvePathValue(env) {
+  return combinePathValuesForPlatform([env.PATH, env.Path, env.path]);
+}
+export function runStderrGuardedProbe(command, args) {
+  try {
+    const { execFileSync } = require("node:child_process");
+    const out = execFileSync(command, args, {
+      timeout: 3000,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    return out.trim();
+  } catch {
+    return "";
+  }
+}
+function readWindowsRegistryPath() {
+  return runStderrGuardedProbe("powershell.exe", [
+    "-NoProfile",
+    "-NonInteractive",
+    "-Command",
+    "[System.Environment]::GetEnvironmentVariable('Path','Machine') + ';' + [System.Environment]::GetEnvironmentVariable('Path','User')"
+  ]);
+}
+let _liveWindowsPath = null;
+function getLiveWindowsPath() {
+  if (_liveWindowsPath === null) {
+    _liveWindowsPath = readWindowsRegistryPath();
+  }
+  return _liveWindowsPath;
+}
+async function buildAugmentedPath(basePath) {
+  const candidates = [];
+  const nodeDir = path.dirname(process.execPath);
+  if (nodeDir) {
+    candidates.push(nodeDir);
+  }
+  if (isWindows) {
+    const home = os.homedir();
+    const driveRoot = path.parse(home).root;
+    candidates.push(path.join(home, ".cargo", "bin"));
+    candidates.push(path.join(home, "go", "bin"));
+    candidates.push(path.join(home, ".dotnet", "tools"));
+    candidates.push(DM_LENS_BIN_DIR);
+    candidates.push(DM_LENS_TOOLS_BIN_DIR);
+    candidates.push(path.join(driveRoot, "Program Files", "Go", "bin"));
+    candidates.push(path.join(driveRoot, "Go", "bin"));
+    for (const entry of await getRubyVersionDirNamesAsync(driveRoot)) {
+      candidates.push(path.join(driveRoot, entry, "bin"));
+    }
+  }
+  const effectiveBase = isWindows ? combinePathValuesForPlatform([basePath, getLiveWindowsPath()]) : basePath;
+  const existing = new Set;
+  for (const entry of splitPathEntries(effectiveBase, path.delimiter)) {
+    if (!entry)
+      continue;
+    existing.add(normalizePathEntry(entry, process.platform));
+  }
+  const toAppend = [];
+  for (const candidate of candidates) {
+    if (!candidate || !fs.existsSync(candidate))
+      continue;
+    const normalized = normalizePathEntry(candidate, process.platform);
+    if (existing.has(normalized))
+      continue;
+    toAppend.push(candidate);
+    existing.add(normalized);
+  }
+  if (toAppend.length === 0)
+    return basePath ?? "";
+  if (!basePath)
+    return toAppend.join(path.delimiter);
+  return `${basePath}${path.delimiter}${toAppend.join(path.delimiter)}`;
+}
+export function isCmdShimValid(cmdPath) {
+  try {
+    const content = fs.readFileSync(cmdPath, "utf-8");
+    const match = content.match(/"%~dp0[/\\]\.\.[/\\]((?:[\w./@-]|\\)+\.(?:mjs|cjs|js))"/i);
+    if (!match)
+      return true;
+    const relPath = match[1].replace(/[/\\]/g, path.sep);
+    const target = path.resolve(path.dirname(cmdPath), "..", relPath);
+    return fs.existsSync(target);
+  } catch {
+    return true;
+  }
+}
+function bypassPs1OnWindows(ps1Path, args) {
+  const cmdPath = `${ps1Path.slice(0, -4)}.cmd`;
+  if (fs.existsSync(cmdPath)) {
+    return { command: cmdPath, args, needsShell: true };
+  }
+  try {
+    const content = fs.readFileSync(ps1Path, "utf-8");
+    const match = content.match(/"\$basedir[/\\]\.\.[/\\]((?:[\w./@-]|\\)+\.(?:mjs|cjs|js))"/i);
+    if (match) {
+      const relPath = match[1].replace(/[/\\]/g, path.sep);
+      const jsPath = path.resolve(path.dirname(ps1Path), "..", relPath);
+      if (fs.existsSync(jsPath)) {
+        return {
+          command: process.execPath,
+          args: [jsPath, ...args],
+          needsShell: false
+        };
+      }
+    }
+  } catch {}
+  return;
+}
+function findBinaryOnPath(command, env) {
+  try {
+    const result = execFileSync(isWindows ? "where" : "which", [command], {
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"],
+      env,
+      timeout: 5000
+    }).split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+    for (const candidate of result) {
+      if (fs.existsSync(candidate)) {
+        return candidate;
+      }
+    }
+  } catch {}
+  return;
+}
+function trySpawn(command, args, cwd, env, needsShell) {
+  let proc;
+  if (needsShell) {
+    const escapeCmdArg = (s) => {
+      const escaped = s.replace(/([&|<>^()!])/g, "^$1");
+      return /[\s"]/.test(escaped) ? `"${escaped.replace(/"/g, '""')}"` : escaped;
+    };
+    const shellCommand = `"${command}" ${args.map(escapeCmdArg).join(" ")}`;
+    proc = nodeSpawn(shellCommand, [], {
+      cwd,
+      env,
+      stdio: ["pipe", "pipe", "pipe"],
+      detached: !isWindows,
+      windowsHide: true,
+      shell: true
+    });
+  } else {
+    proc = nodeSpawn(command, args, {
+      cwd,
+      env,
+      stdio: ["pipe", "pipe", "pipe"],
+      detached: !isWindows,
+      windowsHide: isWindows
+    });
+  }
+  if (!proc.stdin || !proc.stdout || !proc.stderr) {
+    throw new Error(`Failed to spawn LSP server: ${command}`);
+  }
+  if (proc.exitCode !== null || proc.killed) {
+    throw new Error(`LSP server ${command} exited immediately (code: ${proc.exitCode}). ` + `The binary may be missing or corrupted.`);
+  }
+  return proc;
+}
+function unrefLspProcessHandles(proc) {
+  try {
+    proc.unref();
+  } catch {}
+  for (const stream of [proc.stdin, proc.stdout, proc.stderr]) {
+    try {
+      stream?.unref?.();
+    } catch {}
+  }
+}
+function _attachErrorHandler(proc, context, logContext, rejectOnImmediateError) {
+  let stderrPreview = "";
+  let closeLogged = false;
+  const onStderr = (chunk) => {
+    if (stderrPreview.length >= 4000)
+      return;
+    stderrPreview += chunk.toString();
+  };
+  proc.stderr?.on("data", onStderr);
+  proc.on("error", (err) => {
+    if (logContext) {
+      logSessionStart("lsp process " + context + ": spawn-error command=" + logContext.command + " args=" + JSON.stringify(logContext.args) + " cwd=" + logContext.cwd + " pid=" + (logContext.pid ?? 0) + " error=" + err.message + (stderrPreview ? " stderr=" + compactLogValue(stderrPreview) : ""));
+    }
+    if (rejectOnImmediateError && logContext) {
+      classifySpawnFailure(err, {
+        command: logContext.command,
+        cwd: logContext.cwd
+      }).then(rejectOnImmediateError);
+    }
+  });
+  proc.on("close", (code, signal) => {
+    if (closeLogged)
+      return;
+    closeLogged = true;
+    proc.stderr?.off("data", onStderr);
+    if (code !== 0 && code !== null) {
+      if (logContext) {
+        logSessionStart("lsp process " + context + ": closed code=" + code + (signal ? " signal=" + signal : "") + " command=" + logContext.command + " args=" + JSON.stringify(logContext.args) + " cwd=" + logContext.cwd + " pid=" + (logContext.pid ?? 0) + (stderrPreview ? " stderr=" + compactLogValue(stderrPreview) : ""));
+      }
+    } else if (signal && logContext) {
+      logSessionStart("lsp process " + context + ": closed signal=" + signal + " command=" + logContext.command + " args=" + JSON.stringify(logContext.args) + " cwd=" + logContext.cwd + " pid=" + (logContext.pid ?? 0) + (stderrPreview ? " stderr=" + compactLogValue(stderrPreview) : ""));
+    }
+  });
+}
+export async function launchLSP(command, args = [], options = {}) {
+  const cwd = String(options.cwd ?? process.cwd());
+  const mergedEnv = { ...process.env, ...options.env };
+  const augmentedPath = await buildAugmentedPath(resolvePathValue(mergedEnv));
+  const env = {
+    ...mergedEnv,
+    PATH: augmentedPath,
+    ...isWindows ? { Path: augmentedPath } : {}
+  };
+  const isRelativePath = !isFullyQualified(command) && (command.includes(path.sep) || command.includes("/"));
+  const explicitCommand = isRelativePath ? path.resolve(cwd, command) : command;
+  const resolvedCommand = !isFullyQualified(command) && !command.includes(path.sep) && !command.includes("/") ? findBinaryOnPath(command, env) ?? explicitCommand : explicitCommand;
+  let needsShell = computeNeedsShell(resolvedCommand);
+  let spawnCommand = resolvedCommand;
+  if (!isFullyQualified(command) && !command.includes(path.sep) && !command.includes("/")) {
+    const globalBinPath = await findGlobalBinary(command);
+    if (globalBinPath) {
+      spawnCommand = globalBinPath;
+      needsShell = computeNeedsShell(spawnCommand);
+    }
+  }
+  if (isWindows && /\.(cmd|bat)$/i.test(spawnCommand) && !isCmdShimValid(spawnCommand)) {
+    logSessionStart(`lsp cmd-shim-invalid: ${spawnCommand} target missing — skipping candidate`);
+    const cause = Object.assign(new Error(`LSP .cmd shim target not found: ${spawnCommand}`), { code: "ENOENT" });
+    throw await classifySpawnFailure(cause, { command, cwd });
+  }
+  if (isWindows && /\.ps1$/i.test(spawnCommand)) {
+    const bypass = bypassPs1OnWindows(spawnCommand, args);
+    if (bypass) {
+      logSessionStart(`lsp ps1-bypass: ${spawnCommand} → ${bypass.command} shell=${bypass.needsShell}`);
+      spawnCommand = bypass.command;
+      args = bypass.args;
+      needsShell = bypass.needsShell;
+    } else {
+      logSessionStart(`lsp ps1-bypass: no .cmd or JS entry found for ${spawnCommand}, spawn may hang`);
+    }
+  }
+  let proc;
+  try {
+    proc = trySpawn(spawnCommand, args, cwd, env, needsShell);
+  } catch (err) {
+    if (!isFullyQualified(command) && !command.includes(path.sep) && !command.includes("/")) {
+      const globalBinPath = await findGlobalBinary(command);
+      if (globalBinPath && globalBinPath !== spawnCommand) {
+        const needsShellGlobal = computeNeedsShell(globalBinPath);
+        proc = trySpawn(globalBinPath, args, cwd, env, needsShellGlobal);
+      } else {
+        throw await classifySpawnFailure(err, { command, cwd });
+      }
+    } else {
+      throw await classifySpawnFailure(err, { command, cwd });
+    }
+  }
+  if (!proc.stdin || !proc.stdout || !proc.stderr) {
+    throw new Error(`Failed to spawn LSP server: ${command}`);
+  }
+  if (proc.exitCode !== null || proc.killed) {
+    throw new Error(`LSP server ${command} exited immediately (code: ${proc.exitCode}). ` + `The binary may be missing or corrupted.`);
+  }
+  logSessionStart(`lsp launch: command=${command} resolved=${spawnCommand} args=${JSON.stringify(args)} cwd=${cwd} shell=${needsShell ? "true" : "false"} pid=${proc.pid ?? 0}`);
+  const formatStartupStderr = (stderr) => {
+    const normalized = compactLogValue(stderr);
+    if (!normalized)
+      return "";
+    return ` stderr=${normalized}`;
+  };
+  let startupStderr = "";
+  const onStartupStderr = (chunk) => {
+    if (startupStderr.length >= 4000)
+      return;
+    startupStderr += chunk.toString();
+  };
+  proc.stderr?.on("data", onStartupStderr);
+  try {
+    await new Promise((resolve, reject) => {
+      let settled = false;
+      proc.on("error", (err) => {
+        if (!settled) {
+          settled = true;
+          classifySpawnFailure(err, { command, cwd }).then((failure) => {
+            const detail = formatStartupStderr(startupStderr);
+            reject(detail ? new SpawnFailureError(failure.kind, `${failure.message}${detail}`, failure.cause) : failure);
+          });
+        }
+      });
+      proc.on("exit", (code) => {
+        if (!settled && code !== null) {
+          settled = true;
+          const isWindowsCmd = isWindows && command.endsWith(".cmd");
+          const errorMsg = isWindowsCmd && code === 1 ? `npm .cmd shim failed (underlying binary not installed). Run 'npm install' in this project or use a global installation.` : `The binary may be missing or corrupted.`;
+          reject(new Error(`LSP server ${command} exited immediately with code ${code}. ${errorMsg}${formatStartupStderr(startupStderr)}`));
+        }
+      });
+      const startupFailureWindowMs = (() => {
+        if (options?.startupFailureWindowMs) {
+          return options.startupFailureWindowMs;
+        }
+        if (isWindows && needsShell) {
+          return WINDOWS_NAV_STARTUP_FAILURE_WINDOW_MS;
+        }
+        return DEFAULT_STARTUP_FAILURE_WINDOW_MS;
+      })();
+      setTimeout(() => {
+        if (!settled) {
+          settled = true;
+          resolve();
+        }
+      }, startupFailureWindowMs);
+    });
+  } finally {
+    proc.stderr?.off("data", onStartupStderr);
+  }
+  _attachErrorHandler(proc, command, {
+    command: spawnCommand,
+    args,
+    cwd,
+    pid: proc.pid ?? 0
+  });
+  unrefLspProcessHandles(proc);
+  return {
+    process: proc,
+    stdin: proc.stdin,
+    stdout: proc.stdout,
+    stderr: proc.stderr,
+    pid: proc.pid ?? 0,
+    command: spawnCommand,
+    args
+  };
+}
+export async function launchViaNode(scriptPath, args = [], options = {}) {
+  return launchLSP(process.execPath, [scriptPath, ...args], options);
+}
+export async function launchViaPython(moduleName, args = [], options = {}) {
+  const pythonCmd = process.platform === "win32" ? "py" : "python3";
+  return launchLSP(pythonCmd, ["-m", moduleName, ...args], options);
+}
+export async function stopLSP(handle) {
+  if (handle.process.exitCode !== null || handle.process.signalCode !== null) {
+    return;
+  }
+  return new Promise((resolve) => {
+    let settled = false;
+    let forceTimeout;
+    let giveUpTimeout;
+    const done = () => {
+      if (settled)
+        return;
+      settled = true;
+      if (forceTimeout)
+        clearTimeout(forceTimeout);
+      if (giveUpTimeout)
+        clearTimeout(giveUpTimeout);
+      handle.process.off("exit", done);
+      handle.process.off("error", done);
+      resolve();
+    };
+    handle.process.once("exit", done);
+    handle.process.once("error", done);
+    const killWindowsTree = () => {
+      if (!isWindows || handle.pid <= 0)
+        return false;
+      if (handle.process.exitCode !== null || handle.process.signalCode !== null)
+        return false;
+      try {
+        const taskkill = `${process.env.SystemRoot ?? "C:\\Windows"}\\System32\\taskkill.exe`;
+        const killer = nodeSpawn(taskkill, ["/F", "/T", "/PID", String(handle.pid)], {
+          shell: false,
+          windowsHide: true
+        });
+        killer.once("error", done);
+        return true;
+      } catch {
+        return false;
+      }
+    };
+    try {
+      if (!killWindowsTree()) {
+        handle.process.kill("SIGTERM");
+      }
+    } catch {
+      done();
+      return;
+    }
+    forceTimeout = setTimeout(() => {
+      if (settled)
+        return;
+      try {
+        if (!killWindowsTree()) {
+          handle.process.kill("SIGKILL");
+        }
+      } catch {
+        done();
+        return;
+      }
+      giveUpTimeout = setTimeout(done, 500);
+    }, 5000);
+  });
+}

package/extensions/dm-lens/clients/lsp/lombok.js

@@ -0,0 +1,146 @@
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+const LOMBOK_ENV_KEYS = ["DM_LENS_LOMBOK_JAR", "LOMBOK_JAR"];
+const LOMBOK_PROJECT_FILES = [
+  "lombok.config",
+  "pom.xml",
+  "build.gradle",
+  "build.gradle.kts",
+  path.join("gradle", "libs.versions.toml")
+];
+function fileExists(filePath) {
+  if (!filePath)
+    return false;
+  try {
+    return fs.statSync(filePath).isFile();
+  } catch {
+    return false;
+  }
+}
+function readTextIfSmall(filePath, maxBytes = 512 * 1024) {
+  try {
+    const stat = fs.statSync(filePath);
+    if (!stat.isFile() || stat.size > maxBytes)
+      return "";
+    return fs.readFileSync(filePath, "utf-8");
+  } catch {
+    return "";
+  }
+}
+function containsLombokDependency(text) {
+  return /\borg\.projectlombok\b/i.test(text) || /<artifactId>\s*lombok\s*<\/artifactId>/i.test(text) || /\b(annotationProcessor|compileOnly|testCompileOnly|testAnnotationProcessor)\b[^\n]*\blombok\b/i.test(text);
+}
+export function hasLombokProject(root) {
+  const lombokConfig = path.join(root, "lombok.config");
+  if (fileExists(lombokConfig))
+    return true;
+  for (const name of LOMBOK_PROJECT_FILES) {
+    if (name === "lombok.config")
+      continue;
+    const text = readTextIfSmall(path.join(root, name));
+    if (text && containsLombokDependency(text))
+      return true;
+  }
+  return false;
+}
+function envJarCandidate(env) {
+  for (const key of LOMBOK_ENV_KEYS) {
+    const value = env[key]?.trim();
+    if (fileExists(value))
+      return path.resolve(value);
+  }
+  return;
+}
+function localJarCandidates(root) {
+  return [
+    path.join(root, "lombok.jar"),
+    path.join(root, ".lombok", "lombok.jar"),
+    path.join(root, "lib", "lombok.jar"),
+    path.join(root, "libs", "lombok.jar")
+  ];
+}
+function newestExistingJar(candidates) {
+  let best;
+  for (const candidate of candidates) {
+    try {
+      const stat = fs.statSync(candidate);
+      if (!stat.isFile())
+        continue;
+      if (!best || stat.mtimeMs > best.mtimeMs) {
+        best = { filePath: candidate, mtimeMs: stat.mtimeMs };
+      }
+    } catch {}
+  }
+  return best?.filePath;
+}
+function mavenLocalLombokJar(home = os.homedir()) {
+  const base = path.join(home, ".m2", "repository", "org", "projectlombok", "lombok");
+  let versions = [];
+  try {
+    versions = fs.readdirSync(base);
+  } catch {
+    return;
+  }
+  return newestExistingJar(versions.map((version) => path.join(base, version, `lombok-${version}.jar`)));
+}
+function gradleCacheLombokJar(home = os.homedir()) {
+  const base = path.join(home, ".gradle", "caches", "modules-2", "files-2.1", "org.projectlombok", "lombok");
+  const candidates = [];
+  let versions = [];
+  try {
+    versions = fs.readdirSync(base);
+  } catch {
+    return;
+  }
+  for (const version of versions) {
+    const versionDir = path.join(base, version);
+    let hashes = [];
+    try {
+      hashes = fs.readdirSync(versionDir);
+    } catch {
+      continue;
+    }
+    for (const hash of hashes) {
+      candidates.push(path.join(versionDir, hash, `lombok-${version}.jar`));
+    }
+  }
+  return newestExistingJar(candidates);
+}
+export function resolveLombokJar(root, env = process.env) {
+  const explicit = envJarCandidate(env);
+  if (explicit)
+    return explicit;
+  return newestExistingJar(localJarCandidates(root)) ?? mavenLocalLombokJar() ?? gradleCacheLombokJar();
+}
+export function hasLombokJavaAgent(jvmArgs) {
+  return /(^|\s)-javaagent:(?:"[^"]*lombok[^"]*\.jar"|\S*lombok\S*\.jar)/i.test(jvmArgs ?? "");
+}
+function appendJvmArg(existing, next) {
+  const trimmed = existing?.trim();
+  return trimmed ? `${trimmed} ${next}` : next;
+}
+function resolveLombokJavaAgentArg(root, baseEnv = process.env) {
+  if (baseEnv.DM_LENS_JAVA_LOMBOK === "0")
+    return;
+  if (hasLombokJavaAgent(baseEnv.JDTLS_JVM_ARGS))
+    return;
+  const explicitJar = envJarCandidate(baseEnv);
+  if (!explicitJar && !hasLombokProject(root))
+    return;
+  const jar = explicitJar ?? resolveLombokJar(root, baseEnv);
+  return jar ? `-javaagent:${jar}` : undefined;
+}
+export function createLombokJdtlsArgs(root, baseEnv = process.env) {
+  const javaAgent = resolveLombokJavaAgentArg(root, baseEnv);
+  return javaAgent ? [`--jvm-arg=${javaAgent}`] : [];
+}
+export function createLombokJdtlsEnv(root, baseEnv = process.env) {
+  const javaAgent = resolveLombokJavaAgentArg(root, baseEnv);
+  if (!javaAgent)
+    return;
+  return {
+    ...baseEnv,
+    JDTLS_JVM_ARGS: appendJvmArg(baseEnv.JDTLS_JVM_ARGS, javaAgent)
+  };
+}

package/extensions/dm-lens/clients/lsp/path-utils.js

@@ -0,0 +1,10 @@
+export {
+  isUnderDir,
+  normalizeFilePath,
+  normalizeEphemeralMapKey,
+  normalizeMapKey,
+  pathsEqual,
+  pathToUri,
+  uriToDiskPath,
+  uriToPath
+} from "../path-utils.js";