feat(amazonq): Added LSP Manifest manager related changes

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

@@ -0,0 +1,40 @@
+// 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 com.intellij.openapi.util.text.StringUtil
+import com.intellij.util.io.DigestUtil
+import com.intellij.util.system.CpuArch
+import java.nio.file.Path
+import java.nio.file.Paths
+
+fun getToolkitsCommonCacheRoot(): Path = when {
+    SystemInfo.isWindows -> {
+        Paths.get(System.getenv("LOCALAPPDATA"))
+    }
+    SystemInfo.isMac -> {
+        Paths.get(System.getProperty("user.home"), "Library", "Caches")
+    }
+    else -> {
+        Paths.get(System.getProperty("user.home"), ".cache")
+    }
+}
+
+fun getCurrentOS(): String = when {
+    SystemInfo.isWindows -> "windows"
+    SystemInfo.isMac -> "darwin"
+    else -> "linux"
+}
+
+fun getCurrentArchitecture() = when {
+    CpuArch.CURRENT == CpuArch.X86_64 -> "x64"
+    else -> "arm64"
+}
+
+fun generateMD5Hash(filePath: Path): String {
+    val messageDigest = DigestUtil.md5()
+    DigestUtil.updateContentHash(messageDigest, filePath)
+    return StringUtil.toHexString(messageDigest.digest())
+}

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

@@ -0,0 +1,104 @@
+// 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 org.assertj.core.util.VisibleForTesting
+import software.aws.toolkits.core.utils.deleteIfExists
+import software.aws.toolkits.core.utils.error
+import software.aws.toolkits.core.utils.exists
+import software.aws.toolkits.core.utils.getLogger
+import software.aws.toolkits.core.utils.info
+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.jso"
+    private val manifestManager = ManifestManager()
+    private val lspManifestFilePath: Path = getToolkitsCommonCacheRoot().resolve("aws").resolve("toolkits").resolve("language-servers")
+        .resolve("jetbrains-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
+        }
+        return fetchManifestFromRemote()
+    }
+
+    @VisibleForTesting
+    internal fun fetchManifestFromRemote(): ManifestManager.Manifest? {
+        val manifest: ManifestManager.Manifest?
+        try {
+            val manifestString = getTextFromUrl(lspManifestUrl)
+            manifest = manifestManager.readManifestFile(manifestString) ?: return null
+        } catch (e: Exception) {
+            logger.error(e) { "error fetching lsp manifest from remote URL ${e.message}" }
+            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(e) { "error occurred while saving lsp manifest to local cache ${e.message}" }
+        }
+    }
+
+    @VisibleForTesting
+    internal 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 remote manifest is null or system is offline, re-use localManifest
+        if ((localETag != null && remoteETag != null && localETag == remoteETag) or (localETag != null && remoteETag == null)) {
+            try {
+                val manifestContent = lspManifestFilePath.readText()
+                val manifest = manifestManager.readManifestFile(manifestContent)
+                if (manifest != null) return manifest
+                lspManifestFilePath.deleteIfExists() // delete manifest if it fails to de-serialize
+            } catch (e: Exception) {
+                logger.error(e) { "error reading lsp manifest file from local ${e.message}" }
+                return null
+            }
+        }
+        return null
+    }
+
+    private fun getManifestETagFromLocal(): String? {
+        if (lspManifestFilePath.exists()) {
+            return generateMD5Hash(lspManifestFilePath)
+        }
+        return null
+    }
+
+    private fun getManifestETagFromUrl(): String? {
+        try {
+            val actualETag = getETagFromUrl(lspManifestUrl)
+            return actualETag.trim('"')
+        } catch (e: Exception) {
+            logger.error(e) { "error fetching ETag of lsp manifest from url." }
+        }
+        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 @@
     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 @@
     )
 
     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 @@
     )
 
     data class Manifest(
-        @JsonIgnoreProperties(ignoreUnknown = true)
         @JsonProperty("manifestSchemaVersion")
         val manifestSchemaVersion: String? = null,
         @JsonProperty("artifactId")
@@ -67,7 +64,7 @@
 
     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/amazonq/shared/jetbrains-community/tst/software/aws/toolkits/jetbrains/services/amazonq/lsp/artifacts/ManifestFetcherTest.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 io.mockk.every
+import io.mockk.mockkStatic
+import org.assertj.core.api.Assertions.assertThat
+import org.jetbrains.annotations.TestOnly
+import org.junit.jupiter.api.BeforeEach
+import org.junit.jupiter.api.Test
+import org.mockito.kotlin.atLeastOnce
+import org.mockito.kotlin.never
+import org.mockito.kotlin.reset
+import org.mockito.kotlin.spy
+import org.mockito.kotlin.verify
+import org.mockito.kotlin.whenever
+import software.aws.toolkits.jetbrains.core.getTextFromUrl
+import software.aws.toolkits.jetbrains.services.amazonq.project.manifest.ManifestManager
+
+@TestOnly
+class ManifestFetcherTest {
+
+    private lateinit var manifestFetcher: ManifestFetcher
+    private lateinit var manifest: ManifestManager.Manifest
+    private lateinit var manifestManager: ManifestManager
+
+    @BeforeEach
+    fun setup() {
+        manifestFetcher = spy(ManifestFetcher())
+        manifestManager = spy(ManifestManager())
+        manifest = ManifestManager.Manifest()
+    }
+
+    @Test
+    fun `should return null when both local and remote manifests are null`() {
+        whenever(manifestFetcher.fetchManifestFromLocal()).thenReturn(null)
+        whenever(manifestFetcher.fetchManifestFromRemote()).thenReturn(null)
+
+        assertThat(manifestFetcher.fetch()).isNull()
+    }
+
+    @Test
+    fun `should return valid result from local should not execute remote method`() {
+        reset(manifestFetcher)
+        whenever(manifestFetcher.fetchManifestFromLocal()).thenReturn(manifest)
+
+        assertThat(manifestFetcher.fetch()).isNotNull().isEqualTo(manifest)
+        verify(manifestFetcher, atLeastOnce()).fetchManifestFromLocal()
+        verify(manifestFetcher, never()).fetchManifestFromRemote()
+    }
+
+    @Test
+    fun `should return valid result from remote`() {
+        whenever(manifestFetcher.fetchManifestFromLocal()).thenReturn(null)
+        whenever(manifestFetcher.fetchManifestFromRemote()).thenReturn(manifest)
+
+        assertThat(manifestFetcher.fetch()).isNotNull().isEqualTo(manifest)
+        verify(manifestFetcher, atLeastOnce()).fetchManifestFromLocal()
+        verify(manifestFetcher, atLeastOnce()).fetchManifestFromRemote()
+    }
+
+    @Test
+    fun `fetchManifestFromRemote should return null due to invalid manifestString`() {
+        mockkStatic("software.aws.toolkits.jetbrains.core.HttpUtilsKt")
+        every { getTextFromUrl(any()) } returns "ManifestContent"
+
+        whenever(manifestManager.readManifestFile("")).thenReturn(null)
+
+        assertThat(manifestFetcher.fetchManifestFromRemote()).isNull()
+    }
+
+    @Test
+    fun `fetchManifestFromRemote should return manifest and update manifest`() {
+        val validManifest = ManifestManager.Manifest(manifestSchemaVersion = "1.0")
+        mockkStatic("software.aws.toolkits.jetbrains.core.HttpUtilsKt")
+
+        every { getTextFromUrl(any()) } returns "{ \"manifestSchemaVersion\": \"1.0\" }"
+
+        val result = manifestFetcher.fetchManifestFromRemote()
+        assertThat(result).isNotNull().isEqualTo(validManifest)
+    }
+
+    @Test
+    fun `fetchManifestFromRemote should return null if manifest is deprecated`() {
+        mockkStatic("software.aws.toolkits.jetbrains.core.HttpUtilsKt")
+        every { getTextFromUrl(any()) } returns "ManifestContent"
+
+        val deprecatedManifest = ManifestManager.Manifest(isManifestDeprecated = true)
+
+        whenever(manifestManager.readManifestFile("")).thenReturn(deprecatedManifest)
+
+        assertThat(manifestFetcher.fetchManifestFromRemote()).isNull()
+    }
+
+    @Test
+    fun `fetchManifestFromLocal should return null`() {
+        assertThat(manifestFetcher.fetchManifestFromLocal()).isNull()
+    }
+}

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 @@
             }
 
             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 @@
             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()
+        }