fix(jetbrains): implement dynamic versioning (#2439)

Support switching versions based on generator.version, and correctly
handle the case where the latest version gets bumped.

cli_downloader is only lightly reviewed, it's mostly a claude-generated
translation of the vscode implementation
<!-- ELLIPSIS_HIDDEN -->


----

> [!IMPORTANT]
> Implements dynamic versioning for JetBrains plugin with CLI downloader
and version management, updating language server setup and adding tests.
> 
>   - **Behavior**:
> - Implements dynamic versioning for JetBrains plugin using
`CliDownloader` and `BamlLanguageServerService`.
> - Handles version switching via `generatorVersionNotification()` in
`BamlLanguageClient.kt`.
> - Downloads and verifies CLI binaries using `CliDownloader` and
`ChecksumVerifier`.
>   - **Language Server**:
>     - Updates `BamlLanguageServer` to use dynamic CLI paths.
> - Adds `BamlLanguageServerFactory` and `BamlLanguageServerInstaller`
for server management.
>   - **Configuration**:
> - Adds `DownloadConfig`, `TimeoutConfig`, and `BackoffConfig` for
managing download settings.
> - Introduces `PlatformDetector` and `PlatformMapper` for
platform-specific operations.
>   - **Testing**:
> - Adds unit tests for `CliVersion`, `DownloadConfig`,
`PlatformDetector`, and `PlatformMapper`.
> 
> <sup>This description was created by </sup>[<img alt="Ellipsis"
src="https://img.shields.io/badge/Ellipsis-blue?color=175173">](https://www.ellipsis.dev?ref=BoundaryML%2Fbaml&utm_source=github&utm_medium=referral)<sup>
for d3354a1. You can
[customize](https://app.ellipsis.dev/BoundaryML/settings/summaries) this
summary. It will automatically update as commits are pushed.</sup>


<!-- ELLIPSIS_HIDDEN -->

Author: sxlijin

engine/language_server/src/lib.rs

@@ -1,5 +1,3 @@
-#![allow(dead_code)]
-
 use std::num::NonZeroUsize;
 
 use anyhow::Context;

engine/playground-server/src/server.rs

@@ -58,8 +58,7 @@ async fn playground_static_assets() -> anyhow::Result<PathBuf> {
     const GITHUB_REPO: &str = "BoundaryML/baml";
 
     if std::env::var("VSCODE_DEBUG_MODE")
-        .map(|v| v == "true")
-        .unwrap_or(false)
+        .is_ok_and(|v| v.to_lowercase() == "true" || v.to_lowercase() == "1")
     {
         // Use cargo-relative path for local dist
         let local_dist = std::path::Path::new(env!("CARGO_MANIFEST_DIR"))

engine/zed/src/lib.rs

@@ -16,9 +16,7 @@ struct BamlBinary {
     args: Option<Vec<String>>,
 }
 
-struct BamlExtension {
-    cached_binary_path: Option<String>,
-}
+struct BamlExtension {}
 
 impl BamlExtension {
     fn language_server_binary(
@@ -145,9 +143,7 @@ impl BamlExtension {
 
 impl zed::Extension for BamlExtension {
     fn new() -> Self {
-        Self {
-            cached_binary_path: None,
-        }
+        Self {}
     }
 
     fn language_server_command(
@@ -157,11 +153,11 @@ impl zed::Extension for BamlExtension {
     ) -> Result<zed::Command> {
         let baml_binary = self.language_server_binary(language_server_id, worktree)?;
         Ok(zed::Command {
-            // command: baml_binary.path,
-            command: format!(
-                "{}/../target/debug/language-server-hot-reload",
-                env!("CARGO_MANIFEST_DIR")
-            ),
+            command: baml_binary.path,
+            // command: format!(
+            //     "{}/../target/debug/language-server-hot-reload",
+            //     env!("CARGO_MANIFEST_DIR")
+            // ),
             args: baml_binary.args.unwrap_or_else(|| vec!["lsp".into()]),
             env: Default::default(),
         })

jetbrains/.run/Run Plugin in IDE.run.xml

@@ -4,8 +4,8 @@
     <ExternalSystemSettings>
       <option name="env">
         <map>
-          <entry key="VSCODE_DEBUG_MODE" value="true" />
           <entry key="JETBRAINS_PROJECT_DIR" value="$PROJECT_DIR$" />
+          <entry key="VSCODE_DEBUG_MODE" value="true" />
         </map>
       </option>
       <option name="executionName" />
@@ -20,7 +20,6 @@
           <option value="runIde" />
         </list>
       </option>
-      <option name="vmOptions" value="-Didea.log.console.stdout.level=DEBUG" />
     </ExternalSystemSettings>
     <ExternalSystemDebugServerProcess>true</ExternalSystemDebugServerProcess>
     <ExternalSystemReattachDebugProcess>true</ExternalSystemReattachDebugProcess>

jetbrains/build.gradle.kts

@@ -49,6 +49,14 @@ dependencies {
     }
 
     implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:1.6.3")
+    
+    // CLI Downloader dependencies
+    implementation("com.squareup.okhttp3:okhttp:4.12.0")
+    implementation("org.apache.commons:commons-compress:1.24.0")
+    implementation("org.slf4j:slf4j-api:2.0.9")
+    implementation("ch.qos.logback:logback-classic:1.4.11")
+    implementation("io.github.microutils:kotlin-logging-jvm:3.0.5")
+    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.7.3")
 }
 
 // Configure IntelliJ Platform Gradle Plugin - read more: https://plugins.jetbrains.com/docs/intellij/tools-intellij-platform-gradle-plugin-extension.html

jetbrains/src/main/kotlin/com/boundaryml/jetbrains_ext/BamlCustomServerAPI.kt

@@ -1,15 +1,18 @@
 package com.boundaryml.jetbrains_ext
 
 object BamlIdeConfig {
-    val isDebugMode: Boolean
-    
+    private val isDebugMode: Boolean
+
     init {
         val debugModeEnv = System.getenv("VSCODE_DEBUG_MODE")
         isDebugMode = debugModeEnv == "true"
         println("BamlIdeConfig: VSCODE_DEBUG_MODE=${debugModeEnv ?: "(unset)"}, isDebugMode=$isDebugMode")
     }
-    
+
     fun getPlaygroundUrl(port: Int): String {
         return "http://localhost:$port/"
     }
+
+    fun shouldShowToolWindowDebuggers(): Boolean = isDebugMode
+    fun shouldUseLocalLanguageServerBuild(): Boolean = false
 }

jetbrains/src/main/kotlin/com/boundaryml/jetbrains_ext/BamlGetPortService.kt

@@ -1,4 +1,5 @@
 package com.boundaryml.jetbrains_ext
+
 import com.redhat.devtools.lsp4ij.client.LanguageClientImpl
 import com.intellij.lang.Language
 

jetbrains/src/main/kotlin/com/boundaryml/jetbrains_ext/BamlIdeConfig.kt

@@ -1,22 +1,147 @@
 package com.boundaryml.jetbrains_ext
 
-import BamlCustomServerAPI
-import PortParams
+import com.boundaryml.jetbrains_ext.cli_downloader.CliVersion
+import com.intellij.notification.NotificationGroupManager
+import com.intellij.notification.NotificationType
+import com.intellij.openapi.application.ApplicationManager
+import com.intellij.openapi.components.service
 import com.intellij.openapi.diagnostic.Logger
 import com.intellij.openapi.project.Project
+import com.redhat.devtools.lsp4ij.LanguageServerManager
+import com.redhat.devtools.lsp4ij.LanguageServerManager.StartOptions
+import com.redhat.devtools.lsp4ij.LanguageServerManager.StopOptions
+import com.redhat.devtools.lsp4ij.ServerStatus
 import com.redhat.devtools.lsp4ij.client.LanguageClientImpl
+import com.redhat.devtools.lsp4ij.installation.ServerInstallationContext
+import com.redhat.devtools.lsp4ij.installation.ServerInstallationStatus
+import kotlinx.coroutines.runBlocking
+import org.eclipse.lsp4j.jsonrpc.services.JsonNotification
+import java.nio.file.Paths
+
+
+// Existing data class (keep as-is)
+data class PortParams(val port: Int)
+
+// New data class for version switching
+data class GeneratorVersionPayload(
+    val version: String,
+    val root_path: String
+)
 
 class BamlLanguageClient(project: Project) :
-    LanguageClientImpl(project), BamlCustomServerAPI {
+    LanguageClientImpl(project) {
+
+    private val log = Logger.getInstance(javaClass)
+    private val languageServerService = service<BamlLanguageServerService>()
+
+    // NB(sam): if we need to do something after language server startup, we can apply that hook here
+//    override fun handleServerStatusChanged(serverStatus: ServerStatus) {
+//        super.handleServerStatusChanged(serverStatus)
+//    }
+
+    // Existing port notification (keep exactly as-is but use new service)
+    @JsonNotification("baml/port")
+    fun onPort(params: PortParams) {
+        log.info("Port params: ${params.port}")
+
+        log.info("Setting port to ${params.port}")
+        languageServerService.setPort(params.port)
+        log.info("Set port to ${params.port}")
+    }
+
+    // Phase 2: Full version switching notification processing
+    @JsonNotification("baml_src_generator_version")
+    fun generatorVersionNotification(payload: GeneratorVersionPayload) {
+        log.info("🔄 language server requested that we run a different version: $payload")
+
+        // Process in background to avoid blocking LSP communication
+        ApplicationManager.getApplication().executeOnPooledThread {
+            processVersionSwitchRequest(payload)
+        }
+    }
 
-    private val log = Logger.getInstance(BamlLanguageClient::class.java)
+    private fun processVersionSwitchRequest(payload: GeneratorVersionPayload) {
+        if (BamlIdeConfig.shouldUseLocalLanguageServerBuild()) {
+            log.info("Running in development mode, ignoring version switch request")
+            return
+        }
 
-    override fun onPort(params: PortParams) {
-        Logger.getInstance(javaClass).warn("Port params: ${params.port}")
+        // 1. Validate notification is for current project (equivalent to VSCode's isPathWithinParent)
+        if (!isNotificationForCurrentProject(payload.root_path)) {
+            log.debug("Ignoring version notification for different project: ${payload.root_path}")
+            return
+        }
+
+        // 2. Check if restart already in progress (equivalent to VSCode's isRestarting flag)
+        if (languageServerService.isCurrentlyRestarting()) {
+            log.info("Language server restart already in progress, ignoring request")
+            return
+        }
+
+        // 3. Validate semantic version (equivalent to VSCode's semver.valid check)
+        if (!isValidSemanticVersion(payload.version)) {
+            log.warn("Invalid semantic version received: ${payload.version}")
+            return
+        }
+
+        // 4. Check minimum version requirement (equivalent to VSCode's >= 0.86.0 check)
+        if (!isMinimumVersionSupported(payload.version)) {
+            log.warn("Ignoring version ${payload.version} - below minimum supported version")
+            return
+        }
+
+        // 5. Resolve target CLI path (equivalent to VSCode's resolveCliPath call)
+        runBlocking {
+            // 6. Check if restart is needed (equivalent to VSCode's path comparison)
+            if (languageServerService.getCurrentCliVersion() != payload.version) {
+                // Update version tracking even if no restart needed
+                languageServerService.updateCurrentServer(payload.version)
+                // 7. Execute restart (equivalent to VSCode's executeLanguageServerRestart)
+                log.info("Restarting language server with new version")
+                service<BamlLanguageServerService>().setRestartingFlag(true)
+                // https://github.com/redhat-developer/lsp4ij/blob/main/docs/DeveloperGuide.md#install-language-server
+                // Stops the language server if it is currently starting or already started.
+                //Resets the installer's internal state.
+                //Executes the installation via checkInstallation(context).
+                //If the server was previously running, it restarts it once the installation completes.
+                val context = ServerInstallationContext()
+                    .setForceInstall(true)
+                LanguageServerManager.getInstance(project)
+                    .install("baml-language-server", context)
+            }
+            log.info("Already using correct CLI version, no restart needed")
+
+        }
+    }
+
+    private fun isNotificationForCurrentProject(rootPath: String): Boolean {
+        val projectBasePath = project.basePath ?: return false
+        return try {
+            val notificationPath = Paths.get(rootPath).normalize()
+            val projectPath = Paths.get(projectBasePath).normalize()
+            // Check if paths overlap (either direction)
+            notificationPath.startsWith(projectPath) || projectPath.startsWith(notificationPath)
+        } catch (e: Exception) {
+            log.warn("Error validating project path: $rootPath", e)
+            false
+        }
+    }
+
+    private fun isValidSemanticVersion(version: String): Boolean {
+        // Basic semantic version validation (x.y.z pattern)
+        return version.matches(Regex("\\d+\\.\\d+\\.\\d+.*"))
+    }
 
-        System.out.println("Setting port to ${params.port}")
-        project.getService(BamlGetPortService::class.java)
-            .setPort(params.port)
-        System.out.println("Set port to ${params.port}")
+    private fun isMinimumVersionSupported(version: String): Boolean {
+        // Only versions 0.86.0+ support this notification (like VSCode)
+        return try {
+            val versionParts = version.split(".")
+            if (versionParts.size < 3) return false
+            val major = versionParts[0].toInt()
+            val minor = versionParts[1].toInt()
+            major > 0 || (major == 0 && minor >= 86)
+        } catch (e: Exception) {
+            false
+        }
     }
 }