pybao-cli 1.3.87 → 1.3.89

package/dist/{chunk-3RXA6IWG.js → chunk-BBZOZE5U.js}

@@ -3,7 +3,7 @@ const require = __pybCreateRequire(import.meta.url);
 import {
   SESSION_ID,
   resolveXdgCachePath
-} from "./chunk-KUIDN7FP.js";
+} from "./chunk-LNJEAGUM.js";
 
 // src/utils/log/debugLogger.ts
 import { existsSync, mkdirSync, appendFileSync } from "fs";

package/dist/{chunk-BPN5QY2K.js → chunk-CU7LUROX.js}

@@ -2,11 +2,11 @@ import { createRequire as __pybCreateRequire } from "node:module";
 const require = __pybCreateRequire(import.meta.url);
 import {
   listAllContentFiles
-} from "./chunk-6XDESUHK.js";
+} from "./chunk-52XBAAOD.js";
 import {
   getCwd,
   logError
-} from "./chunk-KUIDN7FP.js";
+} from "./chunk-LNJEAGUM.js";
 
 // src/utils/fs/file.ts
 import {

package/dist/{chunk-GEHCREEY.js → chunk-CUICIV5I.js}

@@ -8,14 +8,14 @@ import {
   getSettingsFileCandidates,
   loadSettingsWithLegacyFallback,
   saveSettingsToPrimaryAndSyncLegacy
-} from "./chunk-F47KO7J2.js";
+} from "./chunk-ZMKBSLLD.js";
 import {
   getCurrentProjectConfig
-} from "./chunk-4GB3OWJY.js";
+} from "./chunk-QQP7RZHT.js";
 import {
   getCwd,
   logError
-} from "./chunk-KUIDN7FP.js";
+} from "./chunk-LNJEAGUM.js";
 
 // src/utils/permissions/toolPermissionSettings.ts
 function uniqueStrings(value) {

package/dist/{chunk-KEALJIDY.js → chunk-HENGZ5QD.js}

@@ -2,15 +2,15 @@ import { createRequire as __pybCreateRequire } from "node:module";
 const require = __pybCreateRequire(import.meta.url);
 import {
   loadSettingsWithLegacyFallback
-} from "./chunk-F47KO7J2.js";
+} from "./chunk-ZMKBSLLD.js";
 import {
   debug
-} from "./chunk-3RXA6IWG.js";
+} from "./chunk-BBZOZE5U.js";
 import {
   env,
   getCwd,
   resolveXdgDataPath
-} from "./chunk-KUIDN7FP.js";
+} from "./chunk-LNJEAGUM.js";
 import {
   __require
 } from "./chunk-I3J4JYES.js";
@@ -76,6 +76,29 @@ async function findNearestRoot(startDir, markers, options) {
 var __filename = fileURLToPath(import.meta.url);
 var __dirname = dirname(__filename);
 var lspInstallDir = getLspBinDir();
+var installNotices = [];
+var HEAVY_LSP_SERVERS = /* @__PURE__ */ new Set([
+  "eslint",
+  "vue-language-server",
+  "jdtls",
+  "metals",
+  "elixir-ls",
+  "haskell-language-server",
+  "zls",
+  "lua-language-server"
+]);
+function addInstallNotice(notice) {
+  installNotices.push(notice);
+  if (installNotices.length > 50) {
+    installNotices.shift();
+  }
+}
+function getInstallNotices() {
+  return [...installNotices];
+}
+function __resetInstallNoticesForTests() {
+  installNotices.length = 0;
+}
 function parseBoolean(value) {
   if (value === void 0) return void 0;
   const normalized = value.trim().toLowerCase();
@@ -95,6 +118,81 @@ async function isAutoInstallEnabled() {
   if (enabled === false) return false;
   return env.hasInternetAccess();
 }
+function getInstallTimeoutMs() {
+  const override = Number.parseInt(process.env.PYB_LSP_INSTALL_TIMEOUT_MS ?? "", 10);
+  if (Number.isFinite(override)) {
+    if (override <= 0) return null;
+    return override;
+  }
+  return 12e4;
+}
+async function runInstallWithPolicy(serverId, install) {
+  const isHeavy = HEAVY_LSP_SERVERS.has(serverId);
+  const startAt = Date.now();
+  if (isHeavy) {
+    addInstallNotice({
+      server: serverId,
+      stage: "start",
+      message: `${serverId} install started`,
+      at: startAt
+    });
+    console.log(`[LSP] ${serverId} install started`);
+  }
+  const timeoutMs = getInstallTimeoutMs();
+  let timeoutId = null;
+  const timeoutPromise = timeoutMs === null ? null : new Promise((resolve) => {
+    timeoutId = setTimeout(() => resolve({ timeout: true }), timeoutMs);
+  });
+  const installPromise = install().then((ok) => ({ ok })).catch((error) => ({ error }));
+  const result = timeoutPromise ? await Promise.race([installPromise, timeoutPromise]) : await installPromise;
+  if (timeoutId) clearTimeout(timeoutId);
+  if ("timeout" in result) {
+    addInstallNotice({
+      server: serverId,
+      stage: "timeout",
+      message: `${serverId} install timed out`,
+      at: Date.now()
+    });
+    if (isHeavy) {
+      console.log(`[LSP] ${serverId} install timed out`);
+    }
+    return false;
+  }
+  if ("error" in result) {
+    addInstallNotice({
+      server: serverId,
+      stage: "failed",
+      message: `${serverId} install failed: ${String(result.error)}`,
+      at: Date.now()
+    });
+    if (isHeavy) {
+      console.log(`[LSP] ${serverId} install failed: ${String(result.error)}`);
+    }
+    return false;
+  }
+  if (!result.ok) {
+    addInstallNotice({
+      server: serverId,
+      stage: "failed",
+      message: `${serverId} install failed`,
+      at: Date.now()
+    });
+    if (isHeavy) {
+      console.log(`[LSP] ${serverId} install failed`);
+    }
+    return false;
+  }
+  if (isHeavy) {
+    addInstallNotice({
+      server: serverId,
+      stage: "success",
+      message: `${serverId} install completed`,
+      at: Date.now()
+    });
+    console.log(`[LSP] ${serverId} install completed`);
+  }
+  return true;
+}
 function ensureInstallDir() {
   if (!existsSync2(lspInstallDir)) {
     mkdirSync(lspInstallDir, { recursive: true });
@@ -151,6 +249,21 @@ async function runBinary(cmd, extraEnv, cwd = lspInstallDir) {
   }
   return { ok: false, error: stderr || stdout };
 }
+async function runBinaryWithTimeout(cmd, extraEnv, cwd, timeoutMs) {
+  if (timeoutMs === null) {
+    return runBinary(cmd, extraEnv, cwd);
+  }
+  let timeoutId = null;
+  const timeoutPromise = new Promise((resolve) => {
+    timeoutId = setTimeout(() => resolve({ timeout: true }), timeoutMs);
+  });
+  const result = await Promise.race([runBinary(cmd, extraEnv, cwd), timeoutPromise]);
+  if (timeoutId) clearTimeout(timeoutId);
+  if ("timeout" in result) {
+    return { ok: false, timeout: true, error: "timeout" };
+  }
+  return result;
+}
 async function getJavaMajorVersion() {
   const proc = Bun.spawn({
     cmd: ["java", "-version"],
@@ -209,12 +322,13 @@ async function installEslintServer(installDir = lspInstallDir) {
       debug.error("LSP_MISSING_DEP", { server: "eslint", error: `${npmCmd} not found` });
       return false;
     }
-    const installResult = await runBinary([npmCmd, "install"], void 0, finalPath);
+    const timeoutMs = getInstallTimeoutMs();
+    const installResult = await runBinaryWithTimeout([npmCmd, "install"], void 0, finalPath, timeoutMs);
     if (!installResult.ok) {
       debug.error("LSP_INSTALL_FAILED", { server: "eslint", error: installResult.error });
       return false;
     }
-    const compileResult = await runBinary([npmCmd, "run", "compile"], void 0, finalPath);
+    const compileResult = await runBinaryWithTimeout([npmCmd, "run", "compile"], void 0, finalPath, timeoutMs);
     if (!compileResult.ok) {
       debug.error("LSP_INSTALL_FAILED", { server: "eslint", error: compileResult.error });
       return false;
@@ -376,6 +490,17 @@ var DEFAULT_LANGUAGE_CATEGORIES = {
 var EXPERIMENTAL_SWITCHES = {
   ty: { enable: ["ty"], disable: ["pyright"] }
 };
+function readExperimentalEnvToggles() {
+  const out = {};
+  for (const [key, value] of Object.entries(process.env)) {
+    if (!key.startsWith("PYB_LSP_EXPERIMENTAL_")) continue;
+    const name = key.substring("PYB_LSP_EXPERIMENTAL_".length).toLowerCase();
+    const v = String(value ?? "").trim().toLowerCase();
+    const enabled = v === "1" || v === "true" || v === "on" || v === "yes";
+    out[name] = enabled;
+  }
+  return Object.keys(out).length ? out : void 0;
+}
 function isRecord(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
@@ -521,9 +646,15 @@ function hasTyBinary(rootPath) {
 }
 function applyExperimentalSwitches(settings) {
   if (!settings) return void 0;
-  if (!settings.experimental) return settings;
+  const envToggles = readExperimentalEnvToggles();
+  const experimental = settings.experimental || envToggles;
+  if (!experimental) return settings;
   const disabled = new Set(settings.disabledServers ?? []);
-  for (const [key, enabled] of Object.entries(settings.experimental)) {
+  const merged = {
+    ...settings.experimental ?? {},
+    ...envToggles ?? {}
+  };
+  for (const [key, enabled] of Object.entries(merged)) {
     if (!enabled) continue;
     const rule = EXPERIMENTAL_SWITCHES[key];
     if (!rule) continue;
@@ -539,7 +670,8 @@ function applyExperimentalSwitches(settings) {
   }
   return {
     ...settings,
-    disabledServers: disabled.size ? Array.from(disabled) : void 0
+    disabledServers: disabled.size ? Array.from(disabled) : void 0,
+    experimental
   };
 }
 function normalizeLspSettings(value) {
@@ -600,6 +732,8 @@ function detectPythonVenv(rootPath) {
 async function npmInstallIfMissing(packages, cwd = lspInstallDir) {
   const missing = packages.filter((pkg) => !existsSync2(join2(cwd, "node_modules", pkg, "package.json")));
   if (missing.length === 0) return true;
+  const canInstall = await isAutoInstallEnabled();
+  if (!canInstall) return false;
   return bunInstall(missing, cwd);
 }
 function multiResolveBinary(options) {
@@ -782,6 +916,43 @@ async function installJdtls(installDir) {
   }
   return true;
 }
+function resolveMetalsBinary(installDir) {
+  const direct = Bun.which("metals");
+  if (direct) return direct;
+  const local = resolveBinInDir(installDir, "metals");
+  return local || null;
+}
+async function installMetals(installDir) {
+  if (!Bun.which("java")) {
+    throw new Error("java not found");
+  }
+  const javaMajor = await getJavaMajorVersion();
+  if (!javaMajor || javaMajor < 17) {
+    throw new Error("java 17 or newer required");
+  }
+  if (resolveMetalsBinary(installDir)) return true;
+  const installer = Bun.which("cs") ?? Bun.which("coursier");
+  if (!installer) {
+    throw new Error("coursier not found");
+  }
+  if (!existsSync2(installDir)) {
+    mkdirSync(installDir, { recursive: true });
+  }
+  const version = process.env.PYB_METALS_VERSION?.trim();
+  const coord = version ? `metals:${version}` : "metals";
+  const result = await runBinary([installer, "install", coord, "--install-dir", installDir], void 0, installDir);
+  if (!result.ok) {
+    throw new Error(result.error || "metals install failed");
+  }
+  const binary = resolveBinInDir(installDir, "metals");
+  if (!binary) {
+    throw new Error("metals binary not found after install");
+  }
+  if (process.platform !== "win32") {
+    chmodSync(binary, 493);
+  }
+  return true;
+}
 function getJdtlsLauncherJar(installDir) {
   const pluginsDir = join2(installDir, "plugins");
   if (!existsSync2(pluginsDir)) return null;
@@ -873,7 +1044,7 @@ var ServerDefinition = class extends BaseLspServer {
   }
   async prepare() {
     if (this.installStrategy) {
-      return this.installStrategy();
+      return runInstallWithPolicy(this.id, this.installStrategy);
     }
     return true;
   }
@@ -1659,13 +1830,31 @@ var LspServerRegistry = class _LspServerRegistry {
       "tinymist",
       []
     ));
-    this.register(new GenericBinaryServer(
-      "metals",
-      [".scala", ".sbt", ".sc"],
-      ["build.sbt"],
-      "metals",
-      []
-    ));
+    this.register(new ServerDefinition({
+      id: "metals",
+      extensions: [".scala", ".sbt", ".sc"],
+      rootMarkers: ["build.sbt", "build.sc", ".bsp", ".metals"],
+      install: async () => {
+        const installDir = join2(lspInstallDir, "metals");
+        if (resolveMetalsBinary(installDir)) return true;
+        const canInstall = await isAutoInstallEnabled();
+        if (!canInstall) return false;
+        ensureInstallDir();
+        try {
+          await installMetals(installDir);
+          return true;
+        } catch (error) {
+          debug.error("LSP_INSTALL_FAILED", { server: "metals", error: String(error) });
+          return false;
+        }
+      },
+      spawn: async () => {
+        const installDir = join2(lspInstallDir, "metals");
+        const binary = resolveMetalsBinary(installDir);
+        if (!binary) return null;
+        return { command: binary, args: ["--stdio"] };
+      }
+    }));
     this.register(new GenericBinaryServer(
       "haskell-language-server",
       [".hs", ".lhs"],
@@ -1811,6 +2000,8 @@ var LspServerRegistry = class _LspServerRegistry {
 
 export {
   findNearestRoot,
+  getInstallNotices,
+  __resetInstallNoticesForTests,
   getEslintInstallDir,
   getEslintServerPath,
   installEslintServer,
@@ -1826,6 +2017,7 @@ export {
   installZls,
   installElixirLs,
   installJdtls,
+  installMetals,
   ServerDefinition,
   GenericNpmServer,
   LspServerRegistry