feat(amazonq): Added LSP Manifest manager related changes

plugins/amazonq/chat/jetbrains-community/tst/software/aws/toolkits/jetbrains/services/amazonq/lsp/artifacts/ManifestFetcherTest.kt

@@ -0,0 +1,59 @@
+// Copyright 2025 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+package software.aws.toolkits.jetbrains.services.amazonq.lsp.artifacts
+
+import io.mockk.every
+import io.mockk.spyk
+import io.mockk.verify
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.BeforeEach
+import org.junit.jupiter.api.Test
+import software.aws.toolkits.jetbrains.services.amazonq.project.manifest.ManifestManager
+
+class ManifestFetcherTest {
+
+    private lateinit var manifestFetcher: ManifestFetcher
+    private lateinit var manifest: ManifestManager.Manifest
+
+    @BeforeEach
+    fun setup() {
+        manifestFetcher = ManifestFetcher()
+        manifest = ManifestManager.Manifest()
+    }
+
+    @Test
+    fun `should return null when both local and remote manifests are null`() {
+        val fetchLocalManifestMock = spyk<ManifestFetcher>(recordPrivateCalls = true)
+
+        every { fetchLocalManifestMock["fetchManifestFromLocal"]() } returns null
+        every { fetchLocalManifestMock["fetchManifestFromRemote"]() } returns null
+
+        assertEquals(fetchLocalManifestMock.fetch(), null)
+        verify { fetchLocalManifestMock["fetchManifestFromLocal"]() }
+        verify { fetchLocalManifestMock["fetchManifestFromRemote"]() }
+    }
+
+    @Test
+    fun `should return valid result from local should not execute remote method`() {
+        val fetchLocalManifestMock = spyk<ManifestFetcher>(recordPrivateCalls = true)
+
+        every { fetchLocalManifestMock["fetchManifestFromLocal"]() } returns manifest
+        every { fetchLocalManifestMock["fetchManifestFromRemote"]() } returns null
+
+        assertEquals(fetchLocalManifestMock.fetch(), manifest)
+        verify { fetchLocalManifestMock["fetchManifestFromLocal"]() }
+    }
+
+    @Test
+    fun `should return valid result from remote`() {
+        val fetchLocalManifestMock = spyk<ManifestFetcher>(recordPrivateCalls = true)
+
+        every { fetchLocalManifestMock["fetchManifestFromLocal"]() } returns null
+        every { fetchLocalManifestMock["fetchManifestFromRemote"]() } returns manifest
+
+        assertEquals(fetchLocalManifestMock.fetch(), manifest)
+        verify { fetchLocalManifestMock["fetchManifestFromLocal"]() }
+        verify { fetchLocalManifestMock["fetchManifestFromRemote"]() }
+    }
+}

plugins/amazonq/shared/jetbrains-community/src/software/aws/toolkits/jetbrains/services/amazonq/lsp/artifacts/LspUtils.kt

@@ -0,0 +1,20 @@
+// Copyright 2025 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+package software.aws.toolkits.jetbrains.services.amazonq.lsp.artifacts
+
+import com.intellij.openapi.util.SystemInfo
+import java.nio.file.Path
+import java.nio.file.Paths
+
+fun getToolkitsCommonCachePath(): Path = when {
+    SystemInfo.isWindows -> {
+        Paths.get(System.getenv("APPDATA"))
+    }
+    SystemInfo.isMac -> {
+        Paths.get(System.getProperty("user.home"), "Library", "Caches")
+    }
+    else -> {
+        Paths.get(System.getProperty("user.home"), ".cache")
+    }
+}

plugins/amazonq/shared/jetbrains-community/src/software/aws/toolkits/jetbrains/services/amazonq/lsp/artifacts/ManifestFetcher.kt

@@ -0,0 +1,100 @@
+// Copyright 2025 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+package software.aws.toolkits.jetbrains.services.amazonq.lsp.artifacts
+
+import com.intellij.openapi.util.text.StringUtil
+import com.intellij.util.io.DigestUtil
+import software.aws.toolkits.core.utils.exists
+import software.aws.toolkits.core.utils.getLogger
+import software.aws.toolkits.core.utils.readText
+import software.aws.toolkits.jetbrains.core.getETagFromUrl
+import software.aws.toolkits.jetbrains.core.getTextFromUrl
+import software.aws.toolkits.jetbrains.core.saveFileFromUrl
+import software.aws.toolkits.jetbrains.services.amazonq.project.manifest.ManifestManager
+import java.nio.file.Path
+
+class ManifestFetcher {
+
+    private val lspManifestUrl = "https://aws-toolkit-language-servers.amazonaws.com/codewhisperer/0/manifest.json"
+    private val manifestManager = ManifestManager()
+    private val lspManifestFilePath: Path = getToolkitsCommonCachePath().resolve("aws").resolve("toolkits").resolve("language-servers")
+        .resolve("lsp-manifest.json")
+
+    companion object {
+        private val logger = getLogger<ManifestFetcher>()
+    }
+
+    /**
+     * Method which will be used to fetch latest manifest.
+     * */
+    fun fetch(): ManifestManager.Manifest? {
+        val localManifest = fetchManifestFromLocal()
+        if (localManifest != null) {
+            return localManifest
+        }
+        val remoteManifest = fetchManifestFromRemote() ?: return null
+        return remoteManifest
+    }
+
+    private fun fetchManifestFromRemote(): ManifestManager.Manifest? {
+        val manifest: ManifestManager.Manifest?
+        try {
+            val manifestString = getTextFromUrl(lspManifestUrl)
+            manifest = manifestManager.readManifestFile(manifestString) ?: return null
+        } catch (e: Exception) {
+            logger.error("error fetching lsp manifest from remote URL ${e.message}", e)
+            return null
+        }
+        if (manifest.isManifestDeprecated == true) {
+            logger.info("Manifest is deprecated")
+            return null
+        }
+        updateManifestCache()
+        logger.info("Using manifest found from remote URL")
+        return manifest
+    }
+
+    private fun updateManifestCache() {
+        try {
+            saveFileFromUrl(lspManifestUrl, lspManifestFilePath)
+        } catch (e: Exception) {
+            logger.error("error occurred while saving lsp manifest to local cache ${e.message}", e)
+        }
+    }
+
+    private fun fetchManifestFromLocal(): ManifestManager.Manifest? {
+        val localETag = getManifestETagFromLocal()
+        val remoteETag = getManifestETagFromUrl()
+        // If local and remote have same ETag, we can re-use the manifest file from local to fetch artifacts.
+        if (localETag != null && remoteETag != null && localETag == remoteETag) {
+            try {
+                val manifestContent = lspManifestFilePath.readText()
+                return manifestManager.readManifestFile(manifestContent)
+            } catch (e: Exception) {
+                logger.error("error reading lsp manifest file from local ${e.message}", e)
+                return null
+            }
+        }
+        return null
+    }
+
+    private fun getManifestETagFromLocal(): String? {
+        if (lspManifestFilePath.exists()) {
+            val messageDigest = DigestUtil.md5()
+            DigestUtil.updateContentHash(messageDigest, lspManifestFilePath)
+            return StringUtil.toHexString(messageDigest.digest())
+        }
+        return null
+    }
+
+    private fun getManifestETagFromUrl(): String? {
+        try {
+            val actualETag = getETagFromUrl(lspManifestUrl)
+            return actualETag.trim('"')
+        } catch (e: Exception) {
+            logger.error("error fetching ETag of lsp manifest from url.", e)
+        }
+        return null
+    }
+}

plugins/amazonq/shared/jetbrains-community/src/software/aws/toolkits/jetbrains/services/amazonq/project/manifest/ManifestManager.kt

@@ -3,8 +3,8 @@
 
 package software.aws.toolkits.jetbrains.services.amazonq.project.manifest
 
-import com.fasterxml.jackson.annotation.JsonIgnoreProperties
 import com.fasterxml.jackson.annotation.JsonProperty
+import com.fasterxml.jackson.databind.DeserializationFeature
 import com.fasterxml.jackson.module.kotlin.jacksonObjectMapper
 import com.fasterxml.jackson.module.kotlin.readValue
 import com.intellij.openapi.util.SystemInfo
@@ -18,10 +18,9 @@ class ManifestManager {
     val currentVersion = "0.1.32"
     val currentOs = getOs()
     private val arch = CpuArch.CURRENT
-    private val mapper = jacksonObjectMapper()
+    private val mapper = jacksonObjectMapper().apply { configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false) }
 
     data class TargetContent(
-        @JsonIgnoreProperties(ignoreUnknown = true)
         @JsonProperty("filename")
         val filename: String? = null,
         @JsonProperty("url")
@@ -33,16 +32,15 @@ class ManifestManager {
     )
 
     data class VersionTarget(
-        @JsonIgnoreProperties(ignoreUnknown = true)
         @JsonProperty("platform")
         val platform: String? = null,
         @JsonProperty("arch")
         val arch: String? = null,
         @JsonProperty("contents")
         val contents: List<TargetContent>? = emptyList(),
     )
+
     data class Version(
-        @JsonIgnoreProperties(ignoreUnknown = true)
         @JsonProperty("serverVersion")
         val serverVersion: String? = null,
         @JsonProperty("isDelisted")
@@ -52,7 +50,6 @@ class ManifestManager {
     )
 
     data class Manifest(
-        @JsonIgnoreProperties(ignoreUnknown = true)
         @JsonProperty("manifestSchemaVersion")
         val manifestSchemaVersion: String? = null,
         @JsonProperty("artifactId")
@@ -67,7 +64,7 @@ class ManifestManager {
 
     fun getManifest(): Manifest? = fetchFromRemoteAndSave()
 
-    private fun readManifestFile(content: String): Manifest? {
+    fun readManifestFile(content: String): Manifest? {
         try {
             return mapper.readValue<Manifest>(content)
         } catch (e: Exception) {

plugins/core/jetbrains-community/src/software/aws/toolkits/jetbrains/core/DefaultRemoteResourceResolverProvider.kt

@@ -4,7 +4,6 @@
 package software.aws.toolkits.jetbrains.core
 
 import com.intellij.openapi.application.PathManager
-import com.intellij.util.io.HttpRequests
 import com.intellij.util.io.createDirectories
 import software.aws.toolkits.core.utils.DefaultRemoteResourceResolver
 import software.aws.toolkits.core.utils.UrlFetcher
@@ -41,11 +40,7 @@ class DefaultRemoteResourceResolverProvider : RemoteResourceResolverProvider {
             }
 
             override fun getETag(url: String): String =
-                HttpRequests.head(url)
-                    .userAgent("AWS Toolkit for JetBrains")
-                    .connect { request ->
-                        request.connection.headerFields["ETag"]?.firstOrNull().orEmpty()
-                    }
+                getETagFromUrl(url)
         }
     }
 }

plugins/core/jetbrains-community/src/software/aws/toolkits/jetbrains/core/HttpUtils.kt

@@ -24,3 +24,10 @@ fun writeJsonToUrl(url: String, jsonString: String, indicator: ProgressIndicator
             request.write(jsonString)
             request.readString(indicator)
         }
+
+fun getETagFromUrl(url: String): String =
+    HttpRequests.head(url)
+        .userAgent(AwsClientManager.getUserAgent())
+        .connect { request ->
+            request.connection.headerFields["ETag"]?.firstOrNull().orEmpty()
+        }