repowisestage 0.0.50 → 0.0.52

package/dist/bin/repowise.js

@@ -669,6 +669,7 @@ var init_registry = __esm({
           extensions: [".java"],
           lspLanguageId: "java",
           installHint: "brew install jdtls (see https://github.com/eclipse-jdtls/eclipse.jdt.ls)",
+          nativeInstallKey: "jdtls",
           initializationOptions: {
             bundles: [],
             extendedClientCapabilities: {
@@ -784,7 +785,8 @@ var init_registry = __esm({
           args: [],
           extensions: [".kt", ".kts"],
           lspLanguageId: "kotlin",
-          installHint: "brew install kotlin-language-server (or see https://github.com/fwcd/kotlin-language-server)"
+          installHint: "brew install kotlin-language-server (or see https://github.com/fwcd/kotlin-language-server)",
+          nativeInstallKey: "kotlin-language-server"
         }
       ],
       swift: [
@@ -1070,44 +1072,44 @@ var init_lsp_versions = __esm({
     "use strict";
     NATIVE_LSP_VERSIONS = {
       "rust-analyzer": {
-        repo: "rust-lang/rust-analyzer",
-        version: "2025-01-09",
+        source: { kind: "github-release", repo: "rust-lang/rust-analyzer" },
+        version: "2026-05-11",
         license: "MIT OR Apache-2.0",
         assets: {
           "darwin-arm64": {
             filename: "rust-analyzer-aarch64-apple-darwin.gz",
-            sha256: null,
+            sha256: "eeb6367cd2c6cc9217ae06cea2e0c7e9cf20cdac5e934a1b272b13c76ece5aee",
             binaryPath: "rust-analyzer-aarch64-apple-darwin"
           },
           "darwin-x64": {
             filename: "rust-analyzer-x86_64-apple-darwin.gz",
-            sha256: null,
+            sha256: "718398822ec2f282bca36f6f109bbbb33746437e1a63946fe7fd3d84d502a67d",
             binaryPath: "rust-analyzer-x86_64-apple-darwin"
           },
           "linux-x64": {
             filename: "rust-analyzer-x86_64-unknown-linux-gnu.gz",
-            sha256: null,
+            sha256: "ede62b8536a37c90d804850d0bed3623e3d6af90a1195e4930a1627e5d8ae33f",
             binaryPath: "rust-analyzer-x86_64-unknown-linux-gnu"
           },
           "linux-arm64": {
             filename: "rust-analyzer-aarch64-unknown-linux-gnu.gz",
-            sha256: null,
+            sha256: "dbe8c4c0bed79f36133c9d0a0eb629709d91343e065a179cd4a5f8137817de1c",
             binaryPath: "rust-analyzer-aarch64-unknown-linux-gnu"
           },
           "win32-x64": {
             filename: "rust-analyzer-x86_64-pc-windows-msvc.zip",
-            sha256: null,
+            sha256: "1600365f2d8b0e42a811eafb5e129b75b991ddf9d9955d19d8fc2f4f2b9c19ef",
             binaryPath: "rust-analyzer.exe"
           },
           "win32-arm64": {
             filename: "rust-analyzer-aarch64-pc-windows-msvc.zip",
-            sha256: null,
+            sha256: "3cd63d31e9abfea89488eebfd2c29d41550af6cb6f6b32f52e455fb783215fd0",
             binaryPath: "rust-analyzer.exe"
           }
         }
       },
       clangd: {
-        repo: "clangd/clangd",
+        source: { kind: "github-release", repo: "clangd/clangd" },
         version: "18.1.3",
         license: "Apache-2.0 WITH LLVM-exception",
         assets: {
@@ -1115,22 +1117,22 @@ var init_lsp_versions = __esm({
           // architectures — same filename for darwin-arm64 and darwin-x64.
           "darwin-arm64": {
             filename: "clangd-mac-18.1.3.zip",
-            sha256: null,
+            sha256: "442c18d98671d8b5d811b25002ad1f2fd0b9efb07e7905a41502f1f1311dc566",
             binaryPath: "clangd_18.1.3/bin/clangd"
           },
           "darwin-x64": {
             filename: "clangd-mac-18.1.3.zip",
-            sha256: null,
+            sha256: "442c18d98671d8b5d811b25002ad1f2fd0b9efb07e7905a41502f1f1311dc566",
             binaryPath: "clangd_18.1.3/bin/clangd"
           },
           "linux-x64": {
             filename: "clangd-linux-18.1.3.zip",
-            sha256: null,
+            sha256: "775f6ac798d9c599258e3f4fa14d0af908b1801d38250e72a18fb907b28a1be6",
             binaryPath: "clangd_18.1.3/bin/clangd"
           },
           "win32-x64": {
             filename: "clangd-windows-18.1.3.zip",
-            sha256: null,
+            sha256: "3d287d39bab29406f002ff80b939668e59e25ef72346d8f38826305016e45896",
             binaryPath: "clangd_18.1.3/bin/clangd.exe"
           }
         }
@@ -1141,36 +1143,123 @@ var init_lsp_versions = __esm({
       // GitHub-release Tier 1 entry; the magic is what we DO with it after
       // install (see coursier-installer.ts).
       coursier: {
-        repo: "coursier/coursier",
+        source: { kind: "github-release", repo: "coursier/coursier" },
         version: "v2.1.24",
         license: "Apache-2.0",
         assets: {
           "darwin-arm64": {
             filename: "cs-aarch64-apple-darwin.gz",
-            sha256: null,
+            sha256: "53a5728c2016118c8296fa7d5678ddfe122e22dc6c36deb554d771b3b9295b4f",
             binaryPath: "cs"
           },
           "darwin-x64": {
             filename: "cs-x86_64-apple-darwin.gz",
-            sha256: null,
+            sha256: "33913cd6b61658035d9e6fe971e919cb0ef1f659aa7bff7deeded963a2d36385",
             binaryPath: "cs"
           },
           "linux-x64": {
             filename: "cs-x86_64-pc-linux.gz",
-            sha256: null,
-            binaryPath: "cs"
-          },
-          "linux-arm64": {
-            filename: "cs-aarch64-pc-linux-static.gz",
-            sha256: null,
+            sha256: "d2c0572a17fb6146ea65349b59dd216b38beff60ae22bce6e549867c6ed2eda6",
             binaryPath: "cs"
           },
+          // coursier v2.1.24 ships no aarch64-linux build — Scala dev on
+          // ARM Linux falls back to the toolchain-installed Metals path.
           "win32-x64": {
             filename: "cs-x86_64-pc-win32.zip",
-            sha256: null,
+            sha256: "c16b4f95b59fbe035cdda4353cfca78befcbbef5a20a3b151c679717c1504c9f",
             binaryPath: "cs.exe"
           }
         }
+      },
+      // Eclipse JDT Language Server — single cross-platform tarball
+      // hosted at download.eclipse.org. Ships as an Equinox launcher jar
+      // that must be invoked via `java -jar`, so the installer generates
+      // a `bin/jdtls` shim that selects the right config_{platform} dir.
+      // Requires JDK 17+ (jdtls 1.51 minimum).
+      jdtls: {
+        source: { kind: "direct-url" },
+        version: "1.51.0",
+        license: "EPL-2.0",
+        requiresJdk: 17,
+        assets: {
+          "darwin-arm64": {
+            url: "https://download.eclipse.org/jdtls/milestones/1.51.0/jdt-language-server-1.51.0-202510022025.tar.gz",
+            filename: "jdt-language-server-1.51.0-202510022025.tar.gz",
+            sha256: "8a59372117881bf5bdc0220f2254472846b88137c058f344b00a7d41427745a1",
+            binaryPath: "plugins/org.eclipse.equinox.launcher_*.jar",
+            launcherJarGlob: "plugins/org.eclipse.equinox.launcher_*.jar",
+            wrapperBinaryName: "jdtls"
+          },
+          "darwin-x64": {
+            url: "https://download.eclipse.org/jdtls/milestones/1.51.0/jdt-language-server-1.51.0-202510022025.tar.gz",
+            filename: "jdt-language-server-1.51.0-202510022025.tar.gz",
+            sha256: "8a59372117881bf5bdc0220f2254472846b88137c058f344b00a7d41427745a1",
+            binaryPath: "plugins/org.eclipse.equinox.launcher_*.jar",
+            launcherJarGlob: "plugins/org.eclipse.equinox.launcher_*.jar",
+            wrapperBinaryName: "jdtls"
+          },
+          "linux-x64": {
+            url: "https://download.eclipse.org/jdtls/milestones/1.51.0/jdt-language-server-1.51.0-202510022025.tar.gz",
+            filename: "jdt-language-server-1.51.0-202510022025.tar.gz",
+            sha256: "8a59372117881bf5bdc0220f2254472846b88137c058f344b00a7d41427745a1",
+            binaryPath: "plugins/org.eclipse.equinox.launcher_*.jar",
+            launcherJarGlob: "plugins/org.eclipse.equinox.launcher_*.jar",
+            wrapperBinaryName: "jdtls"
+          },
+          "linux-arm64": {
+            url: "https://download.eclipse.org/jdtls/milestones/1.51.0/jdt-language-server-1.51.0-202510022025.tar.gz",
+            filename: "jdt-language-server-1.51.0-202510022025.tar.gz",
+            sha256: "8a59372117881bf5bdc0220f2254472846b88137c058f344b00a7d41427745a1",
+            binaryPath: "plugins/org.eclipse.equinox.launcher_*.jar",
+            launcherJarGlob: "plugins/org.eclipse.equinox.launcher_*.jar",
+            wrapperBinaryName: "jdtls"
+          },
+          "win32-x64": {
+            url: "https://download.eclipse.org/jdtls/milestones/1.51.0/jdt-language-server-1.51.0-202510022025.tar.gz",
+            filename: "jdt-language-server-1.51.0-202510022025.tar.gz",
+            sha256: "8a59372117881bf5bdc0220f2254472846b88137c058f344b00a7d41427745a1",
+            binaryPath: "plugins/org.eclipse.equinox.launcher_*.jar",
+            launcherJarGlob: "plugins/org.eclipse.equinox.launcher_*.jar",
+            wrapperBinaryName: "jdtls"
+          }
+        }
+      },
+      // fwcd/kotlin-language-server — single cross-platform zip on GitHub
+      // releases. Ships a `bin/kotlin-language-server` shell script + a
+      // matching `.bat` for Windows — both invoke `java` internally, so
+      // we just chmod+x and symlink (no shim needed). Requires JDK 11+.
+      "kotlin-language-server": {
+        source: { kind: "github-release", repo: "fwcd/kotlin-language-server" },
+        version: "1.3.13",
+        license: "MIT",
+        requiresJdk: 11,
+        assets: {
+          "darwin-arm64": {
+            filename: "server.zip",
+            sha256: "4fe7d71d087b307c7869036171bd9d8c6a4284cd7c25b89098b0a24eb2d9b6d2",
+            binaryPath: "server/bin/kotlin-language-server"
+          },
+          "darwin-x64": {
+            filename: "server.zip",
+            sha256: "4fe7d71d087b307c7869036171bd9d8c6a4284cd7c25b89098b0a24eb2d9b6d2",
+            binaryPath: "server/bin/kotlin-language-server"
+          },
+          "linux-x64": {
+            filename: "server.zip",
+            sha256: "4fe7d71d087b307c7869036171bd9d8c6a4284cd7c25b89098b0a24eb2d9b6d2",
+            binaryPath: "server/bin/kotlin-language-server"
+          },
+          "linux-arm64": {
+            filename: "server.zip",
+            sha256: "4fe7d71d087b307c7869036171bd9d8c6a4284cd7c25b89098b0a24eb2d9b6d2",
+            binaryPath: "server/bin/kotlin-language-server"
+          },
+          "win32-x64": {
+            filename: "server.zip",
+            sha256: "4fe7d71d087b307c7869036171bd9d8c6a4284cd7c25b89098b0a24eb2d9b6d2",
+            binaryPath: "server/bin/kotlin-language-server.bat"
+          }
+        }
       }
     };
     COURSIER_LSPS = {
@@ -1242,11 +1331,79 @@ var init_src = __esm({
   }
 });
 
+// ../listener/dist/lsp/jdk-probe.js
+import { spawn as spawn3 } from "child_process";
+function parseJavaMajorVersion(stderr) {
+  const modernMatch = /\b(?:openjdk|java) version "(\d+)(?:\.\d+)*(?:[._]\w+)?"/.exec(stderr);
+  if (!modernMatch?.[1])
+    return void 0;
+  const first = Number.parseInt(modernMatch[1], 10);
+  if (!Number.isFinite(first))
+    return void 0;
+  if (first === 1) {
+    const legacyMatch = /\b(?:openjdk|java) version "1\.(\d+)/.exec(stderr);
+    if (legacyMatch?.[1]) {
+      const legacy = Number.parseInt(legacyMatch[1], 10);
+      return Number.isFinite(legacy) ? legacy : void 0;
+    }
+  }
+  return first;
+}
+async function probeJdk(options = {}) {
+  const timeoutMs = options.timeoutMs ?? 5e3;
+  return new Promise((resolve5) => {
+    let stderr = "";
+    let settled = false;
+    const child = spawn3("java", ["-version"], { stdio: ["ignore", "pipe", "pipe"] });
+    const timer = setTimeout(() => {
+      if (settled)
+        return;
+      settled = true;
+      try {
+        child.kill("SIGKILL");
+      } catch {
+      }
+      resolve5({ present: false });
+    }, timeoutMs);
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk.toString("utf8");
+    });
+    child.on("error", () => {
+      if (settled)
+        return;
+      settled = true;
+      clearTimeout(timer);
+      resolve5({ present: false });
+    });
+    child.on("close", (code) => {
+      if (settled)
+        return;
+      settled = true;
+      clearTimeout(timer);
+      if (code !== 0) {
+        resolve5({ present: false, rawOutput: stderr.trim() });
+        return;
+      }
+      const major = parseJavaMajorVersion(stderr);
+      if (major === void 0) {
+        resolve5({ present: true, rawOutput: stderr.trim() });
+        return;
+      }
+      resolve5({ present: true, majorVersion: major, rawOutput: stderr.trim() });
+    });
+  });
+}
+var init_jdk_probe = __esm({
+  "../listener/dist/lsp/jdk-probe.js"() {
+    "use strict";
+  }
+});
+
 // ../listener/dist/lsp/native-installer.js
 import { createWriteStream } from "fs";
 import { promises as fs } from "fs";
 import { createGunzip } from "zlib";
-import { spawn as spawn3 } from "child_process";
+import { spawn as spawn4 } from "child_process";
 import { pipeline } from "stream/promises";
 import { createHash as createHash2 } from "crypto";
 import { join as join14, dirname as dirname5 } from "path";
@@ -1268,16 +1425,43 @@ async function ensureNativeLspInstalled(lspKey) {
   if (!asset) {
     return { installed: false, alreadyPresent: false, skipped: "unsupported-platform" };
   }
+  if (entry.requiresJdk !== void 0) {
+    const jdk = await probeJdk();
+    if (!jdk.present || jdk.majorVersion === void 0 || jdk.majorVersion < entry.requiresJdk) {
+      return {
+        installed: false,
+        alreadyPresent: false,
+        skipped: "jvm-missing",
+        error: `${lspKey} requires JDK ${entry.requiresJdk.toString()}+ (found: ${jdk.present ? `Java ${jdk.majorVersion?.toString() ?? "?"}` : "no java on PATH"}). Install with: brew install openjdk@21 (macOS) or apt install openjdk-21-jdk (Linux)`
+      };
+    }
+  }
+  const usesWrapper = Boolean(asset.launcherJarGlob && asset.wrapperBinaryName);
   const versionDir = join14(getNativeLspDir(), lspKey, entry.version);
-  const installedBinary = join14(versionDir, asset.binaryPath);
-  if (await pathExists(installedBinary)) {
-    await ensureSymlinkInBin(lspKey, installedBinary);
-    return { installed: false, alreadyPresent: true, binaryPath: installedBinary };
+  if (usesWrapper && asset.launcherJarGlob && asset.wrapperBinaryName) {
+    const jarPath = await resolveGlobInsideDir(versionDir, asset.launcherJarGlob);
+    const shimPath = join14(getNativeLspBinDir(), asset.wrapperBinaryName);
+    if (jarPath && await pathExists(shimPath)) {
+      return { installed: false, alreadyPresent: true, binaryPath: shimPath };
+    }
+  } else {
+    const installedBinary = join14(versionDir, asset.binaryPath);
+    if (await pathExists(installedBinary)) {
+      await ensureSymlinkInBin(lspKey, installedBinary, asset.binaryPath);
+      return { installed: false, alreadyPresent: true, binaryPath: installedBinary };
+    }
   }
   try {
     await fs.mkdir(versionDir, { recursive: true });
     const tmpDownload = join14(versionDir, `.${asset.filename}.download`);
-    const downloadUrl = `https://github.com/${entry.repo}/releases/download/${entry.version}/${asset.filename}`;
+    const downloadUrl = entry.source.kind === "github-release" ? `https://github.com/${entry.source.repo}/releases/download/${entry.version}/${asset.filename}` : asset.url ?? "";
+    if (!downloadUrl) {
+      return {
+        installed: false,
+        alreadyPresent: false,
+        error: `direct-url asset for ${lspKey} missing required \`url\` field`
+      };
+    }
     await downloadFile(downloadUrl, tmpDownload);
     if (asset.sha256) {
       const actual = await sha256File(tmpDownload);
@@ -1290,10 +1474,28 @@ async function ensureNativeLspInstalled(lspKey) {
         };
       }
     } else {
-      console.warn(`[lsp-install] WARN: SHA256 verification skipped for ${lspKey} (no pin in NATIVE_LSP_VERSIONS) \u2014 please pin in a follow-up commit`);
+      console.warn(`[lsp-install] WARN: SHA256 verification skipped for ${lspKey} (no pin in NATIVE_LSP_VERSIONS) \u2014 run apps/listener/scripts/pin-native-shas.ts to record one`);
     }
     await extractAsset(tmpDownload, versionDir, asset);
     await fs.unlink(tmpDownload).catch(() => void 0);
+    if (usesWrapper && asset.launcherJarGlob && asset.wrapperBinaryName) {
+      const jarPath = await resolveGlobInsideDir(versionDir, asset.launcherJarGlob);
+      if (!jarPath) {
+        return {
+          installed: false,
+          alreadyPresent: false,
+          error: `extract completed but no JAR matched ${asset.launcherJarGlob} in ${versionDir}`
+        };
+      }
+      const shimPath = await writeJdtlsWrapper({
+        binaryName: asset.wrapperBinaryName,
+        versionDir,
+        launcherJarPath: jarPath
+      });
+      await pruneStaleVersions(lspKey, entry.version);
+      return { installed: true, alreadyPresent: false, binaryPath: shimPath };
+    }
+    const installedBinary = join14(versionDir, asset.binaryPath);
     if (!await pathExists(installedBinary)) {
       return {
         installed: false,
@@ -1302,7 +1504,8 @@ async function ensureNativeLspInstalled(lspKey) {
       };
     }
     await fs.chmod(installedBinary, 493).catch(() => void 0);
-    await ensureSymlinkInBin(lspKey, installedBinary);
+    await ensureSymlinkInBin(lspKey, installedBinary, asset.binaryPath);
+    await pruneStaleVersions(lspKey, entry.version);
     return { installed: true, alreadyPresent: false, binaryPath: installedBinary };
   } catch (err) {
     return {
@@ -1312,10 +1515,112 @@ async function ensureNativeLspInstalled(lspKey) {
     };
   }
 }
-async function ensureSymlinkInBin(lspKey, target) {
+async function resolveGlobInsideDir(versionDir, glob) {
+  const parts = glob.split("/");
+  let dir = versionDir;
+  for (let i = 0; i < parts.length - 1; i += 1) {
+    dir = join14(dir, parts[i]);
+  }
+  const pattern = parts[parts.length - 1];
+  const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
+  const re = new RegExp(`^${escaped}$`);
+  let entries;
+  try {
+    entries = await fs.readdir(dir);
+  } catch {
+    return null;
+  }
+  const matches = entries.filter((e) => re.test(e)).sort();
+  const last = matches[matches.length - 1];
+  return last ? join14(dir, last) : null;
+}
+async function pruneStaleVersions(lspKey, currentVersion) {
+  const lspDir = join14(getNativeLspDir(), lspKey);
+  let entries;
+  try {
+    entries = await fs.readdir(lspDir);
+  } catch {
+    return;
+  }
+  await Promise.all(entries.filter((name) => name !== currentVersion).map(async (name) => {
+    try {
+      await fs.rm(join14(lspDir, name), { recursive: true, force: true });
+    } catch {
+    }
+  }));
+}
+function shQuote(value) {
+  return value.replace(/[\\"$`]/g, (ch) => `\\${ch}`);
+}
+function cmdQuote(value) {
+  return value.replace(/"/g, '""').replace(/%/g, "%%");
+}
+async function writeJdtlsWrapper(input) {
+  const binDir = getNativeLspBinDir();
+  await fs.mkdir(binDir, { recursive: true });
+  const shimPath = join14(binDir, input.binaryName);
+  const platformCfgDir = process.platform === "darwin" ? "config_mac" : process.platform === "win32" ? "config_win" : "config_linux";
+  const workspaceBase = join14(input.versionDir, "workspaces");
+  const qLauncher = shQuote(input.launcherJarPath);
+  const qConfig = shQuote(`${input.versionDir}/${platformCfgDir}`);
+  const qWorkspaceBase = shQuote(workspaceBase);
+  const unixScript = `#!/usr/bin/env bash
+# Generated by repowise listener \u2014 do not edit by hand.
+# Invokes Eclipse JDT.LS via the equinox launcher.
+set -euo pipefail
+WS_NAME="\${REPOWISE_JDTLS_WS_NAME:-default}"
+WS_DIR="${qWorkspaceBase}/\${WS_NAME}"
+mkdir -p "$WS_DIR"
+exec java \\
+  -Declipse.application=org.eclipse.jdt.ls.core.id1 \\
+  -Dosgi.bundles.defaultStartLevel=4 \\
+  -Declipse.product=org.eclipse.jdt.ls.core.product \\
+  -Dlog.level=ALL \\
+  -Xms1g \\
+  --add-modules=ALL-SYSTEM \\
+  --add-opens java.base/java.util=ALL-UNNAMED \\
+  --add-opens java.base/java.lang=ALL-UNNAMED \\
+  -jar "${qLauncher}" \\
+  -configuration "${qConfig}" \\
+  -data "$WS_DIR" \\
+  "$@"
+`;
+  await fs.writeFile(shimPath, unixScript);
+  await fs.chmod(shimPath, 493);
+  if (process.platform === "win32") {
+    const winShim = `${shimPath}.cmd`;
+    const cqLauncher = cmdQuote(input.launcherJarPath);
+    const cqConfig = cmdQuote(`${input.versionDir}\\${platformCfgDir}`);
+    const cqWorkspaceBase = cmdQuote(workspaceBase);
+    const winScript = `@echo off\r
+rem Generated by repowise listener\r
+if "%REPOWISE_JDTLS_WS_NAME%"=="" set REPOWISE_JDTLS_WS_NAME=default\r
+set WS_DIR=${cqWorkspaceBase}\\%REPOWISE_JDTLS_WS_NAME%\r
+if not exist "%WS_DIR%" mkdir "%WS_DIR%"\r
+java ^\r
+  -Declipse.application=org.eclipse.jdt.ls.core.id1 ^\r
+  -Dosgi.bundles.defaultStartLevel=4 ^\r
+  -Declipse.product=org.eclipse.jdt.ls.core.product ^\r
+  -Dlog.level=ALL ^\r
+  -Xms1g ^\r
+  --add-modules=ALL-SYSTEM ^\r
+  --add-opens java.base/java.util=ALL-UNNAMED ^\r
+  --add-opens java.base/java.lang=ALL-UNNAMED ^\r
+  -jar "${cqLauncher}" ^\r
+  -configuration "${cqConfig}" ^\r
+  -data "%WS_DIR%" ^\r
+  %*\r
+`;
+    await fs.writeFile(winShim, winScript);
+  }
+  return shimPath;
+}
+async function ensureSymlinkInBin(lspKey, target, sourceAssetPath) {
   const binDir = getNativeLspBinDir();
   await fs.mkdir(binDir, { recursive: true });
-  const linkPath = join14(binDir, lspKey);
+  const winExtMatch = process.platform === "win32" && sourceAssetPath ? /\.(exe|bat|cmd|ps1)$/i.exec(sourceAssetPath) : null;
+  const linkName = winExtMatch ? `${lspKey}${winExtMatch[0].toLowerCase()}` : lspKey;
+  const linkPath = join14(binDir, linkName);
   try {
     await fs.unlink(linkPath);
   } catch {
@@ -1373,7 +1678,7 @@ async function extractAsset(source, destDir, asset) {
 }
 async function runExternal(cmd, args) {
   return new Promise((resolve5, reject) => {
-    const child = spawn3(cmd, args, { stdio: ["ignore", "pipe", "pipe"] });
+    const child = spawn4(cmd, args, { stdio: ["ignore", "pipe", "pipe"] });
     let stderr = "";
     child.stderr.on("data", (chunk) => {
       stderr += chunk.toString();
@@ -1400,12 +1705,13 @@ var init_native_installer = __esm({
     "use strict";
     init_src();
     init_installer();
+    init_jdk_probe();
   }
 });
 
 // ../listener/dist/lsp/coursier-installer.js
 import { promises as fs2 } from "fs";
-import { spawn as spawn4 } from "child_process";
+import { spawn as spawn5 } from "child_process";
 import { join as join15 } from "path";
 function getCoursierBinDir() {
   return join15(getLspInstallDir(), "coursier-bin");
@@ -1462,7 +1768,7 @@ async function ensureCoursierLspInstalled(key) {
 }
 async function runCs(cs, args) {
   return new Promise((resolve5, reject) => {
-    const child = spawn4(cs, args, { stdio: ["ignore", "pipe", "pipe"] });
+    const child = spawn5(cs, args, { stdio: ["ignore", "pipe", "pipe"] });
     let stderr = "";
     child.stderr.on("data", (chunk) => {
       stderr += chunk.toString();
@@ -1494,7 +1800,7 @@ var init_coursier_installer = __esm({
 });
 
 // ../listener/dist/lsp/toolchain-installer.js
-import { spawn as spawn5 } from "child_process";
+import { spawn as spawn6 } from "child_process";
 import { promises as fs3 } from "fs";
 import { homedir as homedir4 } from "os";
 import { join as join16 } from "path";
@@ -1589,7 +1895,7 @@ function getToolchainBinDirs() {
 }
 function runToolchain(cmd, args) {
   return new Promise((resolve5, reject) => {
-    const child = spawn5(cmd, args, { stdio: ["ignore", "pipe", "pipe"] });
+    const child = spawn6(cmd, args, { stdio: ["ignore", "pipe", "pipe"] });
     let stderr = "";
     child.stderr.on("data", (chunk) => {
       stderr += chunk.toString();
@@ -1605,7 +1911,7 @@ function runToolchain(cmd, args) {
 }
 function captureStdout(cmd, args) {
   return new Promise((resolve5, reject) => {
-    const child = spawn5(cmd, args, { stdio: ["ignore", "pipe", "pipe"] });
+    const child = spawn6(cmd, args, { stdio: ["ignore", "pipe", "pipe"] });
     let stdout = "";
     let stderr = "";
     child.stdout.on("data", (chunk) => {
@@ -1628,7 +1934,7 @@ async function isCommandOnPath(command) {
     return false;
   const probeCmd = process.platform === "win32" ? "where" : "which";
   return new Promise((resolve5) => {
-    const child = spawn5(probeCmd, [command], { stdio: "ignore", timeout: 5e3 });
+    const child = spawn6(probeCmd, [command], { stdio: "ignore", timeout: 5e3 });
     child.on("error", () => resolve5(false));
     child.on("close", (code) => resolve5(code === 0));
   });
@@ -1651,7 +1957,7 @@ var init_toolchain_installer = __esm({
 // ../listener/dist/lsp/installer.js
 import { promises as fs4 } from "fs";
 import { join as join17, dirname as dirname6 } from "path";
-import { spawn as spawn6 } from "child_process";
+import { spawn as spawn7 } from "child_process";
 function getLspInstallDir() {
   return join17(getConfigDir(), "lsp-servers");
 }
@@ -1710,7 +2016,7 @@ async function runNpmInstall(cwd, pkg2) {
   const nodeDir = dirname6(process.execPath);
   const augmentedPath = process.env.PATH ? `${nodeDir}:${process.env.PATH}` : nodeDir;
   return new Promise((resolve5, reject) => {
-    const child = spawn6(npmCmd, ["install", "--no-audit", "--no-fund", "--silent", pkg2], {
+    const child = spawn7(npmCmd, ["install", "--no-audit", "--no-fund", "--silent", pkg2], {
       cwd,
       stdio: ["ignore", "pipe", "pipe"],
       env: { ...process.env, PATH: augmentedPath }
@@ -1834,6 +2140,7 @@ async function prepareLspServersForRepos(repos, options = {}) {
         alreadyPresent: outcome.alreadyPresent,
         skippedNoNpmPackage: false,
         installMethod: "native",
+        skipped: outcome.skipped,
         hint: outcome.skipped ? nativeConfig.installHint : void 0,
         error: outcome.error
       });
@@ -1848,6 +2155,7 @@ async function prepareLspServersForRepos(repos, options = {}) {
         alreadyPresent: outcome.alreadyPresent,
         skippedNoNpmPackage: false,
         installMethod: "coursier",
+        skipped: outcome.skipped,
         hint: outcome.skipped ? coursierConfig.installHint : void 0,
         error: outcome.error
       });
@@ -1862,6 +2170,7 @@ async function prepareLspServersForRepos(repos, options = {}) {
         alreadyPresent: outcome.alreadyPresent,
         skippedNoNpmPackage: false,
         installMethod: "toolchain",
+        skipped: outcome.skipped,
         // Surface the install hint for any skip reason — toolchain
         // missing means user needs to install it; bundled SDK means
         // user needs the SDK.
@@ -2524,6 +2833,82 @@ var init_lsp_tools = __esm({
   }
 });
 
+// ../listener/dist/lsp/telemetry.js
+var telemetry_exports = {};
+__export(telemetry_exports, {
+  postLspInstallOutcomes: () => postLspInstallOutcomes
+});
+function toOutcomes(results) {
+  return results.map((r) => {
+    const skipped = r.skipped ?? (r.skippedNoNpmPackage ? "no-install-method" : void 0);
+    return {
+      language: r.language,
+      ...r.installMethod ? { installMethod: r.installMethod } : {},
+      installed: r.installed,
+      alreadyPresent: r.alreadyPresent,
+      ...skipped ? { skipped } : {},
+      ...r.error ? { error: r.error.slice(0, 500) } : {}
+    };
+  });
+}
+async function postLspInstallOutcomes(input) {
+  if (process.env["REPOWISE_LSP_INSTALL_TELEMETRY_DISABLED"] === "true")
+    return;
+  if (input.results.length === 0)
+    return;
+  const fetchImpl = input.fetchImpl ?? fetch;
+  const url = `${input.apiUrl.replace(/\/+$/, "")}/v1/listeners/lsp-install-outcome`;
+  const body = JSON.stringify({
+    repoId: input.repoId,
+    outcomes: toOutcomes(input.results)
+  });
+  const attempt = async () => {
+    const ctrl = new AbortController();
+    const timer = setTimeout(() => {
+      ctrl.abort();
+    }, REQUEST_TIMEOUT_MS);
+    try {
+      const res = await fetchImpl(url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${input.authToken}`
+        },
+        body,
+        signal: ctrl.signal
+      });
+      const retriable = res.status >= 500 || res.status === 429;
+      return { ok: res.ok, status: res.status, retriable };
+    } catch {
+      return { ok: false, status: 0, retriable: true };
+    } finally {
+      clearTimeout(timer);
+    }
+  };
+  try {
+    const first = await attempt();
+    if (first.ok)
+      return;
+    if (!first.retriable) {
+      console.warn(`[lsp-telemetry] upload rejected (${first.status.toString()}) \u2014 not retrying`);
+      return;
+    }
+    const second = await attempt();
+    if (!second.ok) {
+      console.warn(`[lsp-telemetry] upload failed after retry (status=${second.status.toString()})`);
+    }
+  } catch (err) {
+    console.warn(`[lsp-telemetry] unexpected failure: ${err instanceof Error ? err.message : String(err)}`);
+  }
+}
+var REQUEST_TIMEOUT_MS;
+var init_telemetry = __esm({
+  "../listener/dist/lsp/telemetry.js"() {
+    "use strict";
+    REQUEST_TIMEOUT_MS = 5e3;
+  }
+});
+
 // bin/repowise.ts
 import { readFileSync as readFileSync3 } from "fs";
 import { fileURLToPath as fileURLToPath4 } from "url";
@@ -4120,7 +4505,7 @@ init_coursier_installer();
 init_toolchain_installer();
 
 // ../listener/dist/lsp/bloop-lifecycle.js
-import { spawn as spawn7 } from "child_process";
+import { spawn as spawn8 } from "child_process";
 function createDefaultBloopLauncher() {
   const attachedRepos = /* @__PURE__ */ new Set();
   return {
@@ -4135,7 +4520,7 @@ function createDefaultBloopLauncher() {
       return new Promise((resolveClose) => {
         let child;
         try {
-          child = spawn7("bloop", ["exit"], { stdio: "ignore" });
+          child = spawn8("bloop", ["exit"], { stdio: "ignore" });
         } catch {
           resolveClose();
           return;
@@ -7215,7 +7600,7 @@ init_installer();
 // ../listener/dist/lib/workspace-prep.js
 init_config_dir();
 import { promises as fs14 } from "fs";
-import { spawn as spawn8, execFile as execFile4 } from "child_process";
+import { spawn as spawn9, execFile as execFile4 } from "child_process";
 import { createWriteStream as createWriteStream2 } from "fs";
 import { join as join30 } from "path";
 import { promisify as promisify3 } from "util";
@@ -7501,7 +7886,7 @@ $ ${cmd.join(" ")}
       reject(new Error("spawnSimple called with empty command"));
       return;
     }
-    const child = spawn8(head, cmd.slice(1), {
+    const child = spawn9(head, cmd.slice(1), {
       cwd: repoRoot,
       stdio: ["ignore", "pipe", "pipe"]
     });
@@ -8912,6 +9297,27 @@ async function startListener() {
           console.warn(`[lsp-install] ${r.language} install failed: ${r.error}`);
         }
       }
+      if (lspResults.length > 0) {
+        const { postLspInstallOutcomes: postLspInstallOutcomes2 } = await Promise.resolve().then(() => (init_telemetry(), telemetry_exports));
+        for (const repo of config2.repos) {
+          const apiUrl = repo.apiUrl ?? config2.defaultApiUrl;
+          if (!apiUrl)
+            continue;
+          try {
+            const fresh = await getValidCredentials();
+            if (!fresh)
+              continue;
+            await postLspInstallOutcomes2({
+              apiUrl,
+              authToken: fresh.accessToken,
+              repoId: repo.repoId,
+              results: lspResults
+            });
+          } catch (telErr) {
+            console.warn("[lsp-telemetry] upload skipped:", telErr instanceof Error ? telErr.message : String(telErr));
+          }
+        }
+      }
     } catch (err) {
       console.warn("[lsp-install] Pre-install scan failed:", err instanceof Error ? err.message : String(err));
     }
@@ -10478,7 +10884,7 @@ async function detectMissingDeps(repoRoot, scopedLanguages) {
 }
 
 // src/lib/dep-installer-runner.ts
-import { spawn as spawn9 } from "child_process";
+import { spawn as spawn10 } from "child_process";
 import { createWriteStream as createWriteStream3 } from "fs";
 import { promises as fs16 } from "fs";
 import { join as join38 } from "path";
@@ -10545,7 +10951,7 @@ $ ${cmd.join(" ")}
       reject(new Error("runSimple called with empty command"));
       return;
     }
-    const child = spawn9(head, cmd.slice(1), {
+    const child = spawn10(head, cmd.slice(1), {
       cwd: repoRoot,
       stdio: ["ignore", "pipe", "pipe"]
     });
@@ -13275,7 +13681,7 @@ init_registry();
 init_native_installer();
 init_coursier_installer();
 init_toolchain_installer();
-import { spawn as spawn10 } from "child_process";
+import { spawn as spawn11 } from "child_process";
 import { resolve as resolve4 } from "path";
 import chalk15 from "chalk";
 async function isOnPath(command) {
@@ -13283,7 +13689,7 @@ async function isOnPath(command) {
   const isWin = process.platform === "win32";
   const probeCmd = isWin ? "where" : "which";
   return new Promise((resolve5) => {
-    const child = spawn10(probeCmd, [command], { stdio: "ignore" });
+    const child = spawn11(probeCmd, [command], { stdio: "ignore" });
     child.on("close", (code) => {
       resolve5(code === 0);
     });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "repowisestage",
-  "version": "0.0.50",
+  "version": "0.0.52",
   "type": "module",
   "description": "AI-optimized codebase context generator",
   "bin": {