fix(update): Implement proper "once" behavior for check_updates setting (#160)

When check_updates is set to "once", the extension now correctly checks
for updates only once per component, preventing repeated GitHub API
calls on every Zed restart.

Previously, the "once" mode would check GitHub API on every restart when
no local installation existed, making it functionally identical to
"always" mode until a download completed.

Changes:
- Add persistence mechanism using .update_checked marker files
- Store downloaded version in marker files for future reference
- Implement has_checked_once() and mark_checked_once() helpers
- Update should_use_local_or_download() to check marker before allowing
download
- Apply fix to all components: JDTLS, Lombok, Debugger, and JDK

Behavior after fix:
- First run: GitHub API called → Download → Create marker with version
- Subsequent runs: No GitHub API call (uses local or returns error)

Marker files created:
- jdtls/.update_checked
- lombok/.update_checked
- debugger/.update_checked
- jdk/.update_checked

Author: tartarughina

src/debugger.rs

@@ -12,7 +12,10 @@ use zed_extension_api::{
 use crate::{
     config::get_java_debug_jar,
     lsp::LspWrapper,
-    util::{create_path_if_not_exists, get_curr_dir, path_to_string, should_use_local_or_download},
+    util::{
+        create_path_if_not_exists, get_curr_dir, mark_checked_once, path_to_string,
+        should_use_local_or_download,
+    },
 };
 
 #[derive(Serialize, Deserialize, Debug)]
@@ -121,9 +124,11 @@ impl Debugger {
         }
 
         // Use local installation if update mode requires it
-        if let Some(path) =
-            should_use_local_or_download(configuration, find_latest_local_debugger(), "debugger")?
-        {
+        if let Some(path) = should_use_local_or_download(
+            configuration,
+            find_latest_local_debugger(),
+            DEBUGGER_INSTALL_PATH,
+        )? {
             self.plugin_path = Some(path.clone());
             return Ok(path);
         }
@@ -159,6 +164,9 @@ impl Debugger {
             format!("Failed to download java-debug fork from {JAVA_DEBUG_PLUGIN_FORK_URL}: {err}")
         })?;
 
+        // Mark the downloaded version for "Once" mode tracking
+        let _ = mark_checked_once(DEBUGGER_INSTALL_PATH, latest_version);
+
         self.plugin_path = Some(jar_path.clone());
         Ok(jar_path)
     }
@@ -260,6 +268,9 @@ impl Debugger {
                 DownloadedFileType::Uncompressed,
             )
             .map_err(|err| format!("Failed to download {url} {err}"))?;
+
+            // Mark the downloaded version for "Once" mode tracking
+            let _ = mark_checked_once(DEBUGGER_INSTALL_PATH, latest_version);
         }
 
         self.plugin_path = Some(jar_path.clone());

src/jdk.rs

@@ -2,11 +2,14 @@ use std::path::{Path, PathBuf};
 
 use zed_extension_api::{
     self as zed, Architecture, DownloadedFileType, LanguageServerId,
-    LanguageServerInstallationStatus, Os, current_platform, download_file,
+    LanguageServerInstallationStatus, Os, current_platform, download_file, serde_json::Value,
     set_language_server_installation_status,
 };
 
-use crate::util::{get_curr_dir, path_to_string, remove_all_files_except};
+use crate::util::{
+    get_curr_dir, mark_checked_once, path_to_string, remove_all_files_except,
+    should_use_local_or_download,
+};
 
 // Errors
 const JDK_DIR_ERROR: &str = "Failed to read into JDK install directory";
@@ -15,6 +18,7 @@ const NO_JDK_DIR_ERROR: &str = "No match for jdk or corretto in the extracted di
 const CORRETTO_REPO: &str = "corretto/corretto-25";
 const CORRETTO_UNIX_URL_TEMPLATE: &str = "https://corretto.aws/downloads/resources/{version}/amazon-corretto-{version}-{platform}-{arch}.tar.gz";
 const CORRETTO_WINDOWS_URL_TEMPLATE: &str = "https://corretto.aws/downloads/resources/{version}/amazon-corretto-{version}-{platform}-{arch}-jdk.zip";
+const JDK_INSTALL_PATH: &str = "jdk";
 
 fn build_corretto_url(version: &str, platform: &str, arch: &str) -> String {
     let template = match zed::current_platform().0 {
@@ -46,9 +50,42 @@ fn get_platform() -> zed::Result<String> {
     }
 }
 
+fn find_latest_local_jdk() -> Option<PathBuf> {
+    let jdk_path = get_curr_dir().ok()?.join(JDK_INSTALL_PATH);
+    std::fs::read_dir(&jdk_path)
+        .ok()?
+        .filter_map(Result::ok)
+        .map(|entry| entry.path())
+        .filter(|path| path.is_dir())
+        .filter_map(|path| {
+            let created_time = std::fs::metadata(&path)
+                .and_then(|meta| meta.created())
+                .ok()?;
+            Some((path, created_time))
+        })
+        .max_by_key(|&(_, time)| time)
+        .map(|(path, _)| path)
+}
+
 pub fn try_to_fetch_and_install_latest_jdk(
     language_server_id: &LanguageServerId,
+    configuration: &Option<Value>,
 ) -> zed::Result<PathBuf> {
+    let jdk_path = get_curr_dir()?.join(JDK_INSTALL_PATH);
+
+    // Check if we should use local installation based on update mode
+    if let Some(path) =
+        should_use_local_or_download(configuration, find_latest_local_jdk(), JDK_INSTALL_PATH)?
+    {
+        return get_jdk_bin_path(&path);
+    }
+
+    // Check for updates, if same version is already downloaded skip download
+    set_language_server_installation_status(
+        language_server_id,
+        &LanguageServerInstallationStatus::CheckingForUpdate,
+    );
+
     let version = zed::latest_github_release(
         CORRETTO_REPO,
         zed_extension_api::GithubReleaseOptions {
@@ -58,16 +95,8 @@ pub fn try_to_fetch_and_install_latest_jdk(
     )?
     .version;
 
-    let jdk_path = get_curr_dir()?.join("jdk");
     let install_path = jdk_path.join(&version);
 
-    // Check for updates, if same version is already downloaded skip download
-
-    set_language_server_installation_status(
-        language_server_id,
-        &LanguageServerInstallationStatus::CheckingForUpdate,
-    );
-
     if !install_path.exists() {
         set_language_server_installation_status(
             language_server_id,
@@ -87,12 +116,19 @@ pub fn try_to_fetch_and_install_latest_jdk(
         )?;
 
         // Remove older versions
-        let _ = remove_all_files_except(jdk_path, version.as_str());
+        let _ = remove_all_files_except(&jdk_path, version.as_str());
+
+        // Mark the downloaded version for "Once" mode tracking
+        let _ = mark_checked_once(JDK_INSTALL_PATH, &version);
     }
 
+    get_jdk_bin_path(&install_path)
+}
+
+fn get_jdk_bin_path(install_path: &Path) -> zed::Result<PathBuf> {
     // Depending on the platform the name of the extracted dir might differ
     // Rather than hard coding, extract it dynamically
-    let extracted_dir = get_extracted_dir(&install_path)?;
+    let extracted_dir = get_extracted_dir(install_path)?;
 
     Ok(install_path
         .join(extracted_dir)

src/jdtls.rs

@@ -19,7 +19,7 @@ use crate::{
     jdk::try_to_fetch_and_install_latest_jdk,
     util::{
         create_path_if_not_exists, get_curr_dir, get_java_exec_name, get_java_executable,
-        get_java_major_version, get_latest_versions_from_tag, path_to_string,
+        get_java_major_version, get_latest_versions_from_tag, mark_checked_once, path_to_string,
         remove_all_files_except, should_use_local_or_download,
     },
 };
@@ -50,7 +50,8 @@ pub fn build_jdtls_launch_args(
     if java_major_version < 21 {
         if is_java_autodownload(configuration) {
             java_executable =
-                try_to_fetch_and_install_latest_jdk(language_server_id)?.join(get_java_exec_name());
+                try_to_fetch_and_install_latest_jdk(language_server_id, configuration)?
+                    .join(get_java_exec_name());
         } else {
             return Err(JAVA_VERSION_ERROR.to_string());
         }
@@ -157,12 +158,17 @@ pub fn try_to_fetch_and_install_latest_jdtls(
 ) -> zed::Result<PathBuf> {
     // Use local installation if update mode requires it
     if let Some(path) =
-        should_use_local_or_download(configuration, find_latest_local_jdtls(), "jdtls")?
+        should_use_local_or_download(configuration, find_latest_local_jdtls(), JDTLS_INSTALL_PATH)?
     {
         return Ok(path);
     }
 
     // Download latest version
+    set_language_server_installation_status(
+        language_server_id,
+        &LanguageServerInstallationStatus::CheckingForUpdate,
+    );
+
     let (last, second_last) = get_latest_versions_from_tag(JDTLS_REPO)?;
 
     let (latest_version, latest_version_build) = download_jdtls_milestone(last.as_ref())
@@ -202,6 +208,9 @@ pub fn try_to_fetch_and_install_latest_jdtls(
 
         // ...and delete other versions
         let _ = remove_all_files_except(prefix, build_directory.as_str());
+
+        // Mark the downloaded version for "Once" mode tracking
+        let _ = mark_checked_once(JDTLS_INSTALL_PATH, &latest_version);
     }
 
     // return jdtls base path
@@ -213,9 +222,11 @@ pub fn try_to_fetch_and_install_latest_lombok(
     configuration: &Option<Value>,
 ) -> zed::Result<PathBuf> {
     // Use local installation if update mode requires it
-    if let Some(path) =
-        should_use_local_or_download(configuration, find_latest_local_lombok(), "lombok")?
-    {
+    if let Some(path) = should_use_local_or_download(
+        configuration,
+        find_latest_local_lombok(),
+        LOMBOK_INSTALL_PATH,
+    )? {
         return Ok(path);
     }
 
@@ -248,6 +259,9 @@ pub fn try_to_fetch_and_install_latest_lombok(
         // ...and delete other versions
 
         let _ = remove_all_files_except(prefix, jar_name.as_str());
+
+        // Mark the downloaded version for "Once" mode tracking
+        let _ = mark_checked_once(LOMBOK_INSTALL_PATH, &latest_version);
     }
 
     // else use it

src/util.rs

@@ -32,6 +32,10 @@ const TAG_UNEXPECTED_FORMAT_ERROR: &str = "Malformed GitHub tags response";
 const PATH_IS_NOT_DIR: &str = "File exists but is not a path";
 const NO_LOCAL_INSTALL_NEVER_ERROR: &str =
     "Update checks disabled (never) and no local installation found";
+const NO_LOCAL_INSTALL_ONCE_ERROR: &str =
+    "Update check already performed once and no local installation found";
+
+const ONCE_CHECK_MARKER: &str = ".update_checked";
 
 /// Create a Path if it does not exist
 ///
@@ -60,6 +64,41 @@ pub fn create_path_if_not_exists<P: AsRef<Path>>(path: P) -> zed::Result<()> {
     }
 }
 
+/// Check if update check has been performed once for a component
+///
+/// # Arguments
+///
+/// * [`component_name`] - The component directory name (e.g., "jdtls", "lombok")
+///
+/// # Returns
+///
+/// Returns true if the marker file exists, indicating a check was already performed
+pub fn has_checked_once(component_name: &str) -> bool {
+    PathBuf::from(component_name)
+        .join(ONCE_CHECK_MARKER)
+        .exists()
+}
+
+/// Mark that an update check has been performed for a component
+///
+/// # Arguments
+///
+/// * [`component_name`] - The component directory name (e.g., "jdtls", "lombok")
+/// * [`version`] - The version that was downloaded
+///
+/// # Returns
+///
+/// Returns Ok(()) if the marker was created successfully
+///
+/// # Errors
+///
+/// Returns an error if the directory or marker file could not be created
+pub fn mark_checked_once(component_name: &str, version: &str) -> zed::Result<()> {
+    let marker_path = PathBuf::from(component_name).join(ONCE_CHECK_MARKER);
+    create_path_if_not_exists(PathBuf::from(component_name))?;
+    fs::write(marker_path, version).map_err(|e| e.to_string())
+}
+
 /// Expand ~ on Unix-like systems
 ///
 /// # Arguments
@@ -140,7 +179,8 @@ pub fn get_java_executable(
     // If the user has set the option, retrieve the latest version of Corretto (OpenJDK)
     if is_java_autodownload(configuration) {
         return Ok(
-            try_to_fetch_and_install_latest_jdk(language_server_id)?.join(java_executable_filename)
+            try_to_fetch_and_install_latest_jdk(language_server_id, configuration)?
+                .join(java_executable_filename),
         );
     }
 
@@ -329,6 +369,7 @@ pub fn remove_all_files_except<P: AsRef<Path>>(prefix: P, filename: &str) -> zed
 ///
 /// # Errors
 /// - Update mode is Never but no local installation found
+/// - Update mode is Once and already checked but no local installation found
 pub fn should_use_local_or_download(
     configuration: &Option<Value>,
     local: Option<PathBuf>,
@@ -341,7 +382,22 @@ pub fn should_use_local_or_download(
                 "{NO_LOCAL_INSTALL_NEVER_ERROR} for {component_name}"
             )),
         },
-        CheckUpdates::Once => Ok(local),
+        CheckUpdates::Once => {
+            // If we have a local installation, use it
+            if let Some(path) = local {
+                return Ok(Some(path));
+            }
+
+            // If we've already checked once, don't check again
+            if has_checked_once(component_name) {
+                return Err(format!(
+                    "{NO_LOCAL_INSTALL_ONCE_ERROR} for {component_name}"
+                ));
+            }
+
+            // First time checking - allow download
+            Ok(None)
+        }
         CheckUpdates::Always => Ok(None),
     }
 }