feat(amazonq): fallback to bundled flare assets if cannot be downloaded

plugins/amazonq/build.gradle.kts

@@ -1,17 +1,24 @@
 // Copyright 2024 Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
 
-import org.jetbrains.intellij.platform.gradle.IntelliJPlatformType
+import com.fasterxml.jackson.databind.DeserializationFeature
+import com.fasterxml.jackson.module.kotlin.jacksonObjectMapper
+import de.undercouch.gradle.tasks.download.Download
+import org.jetbrains.intellij.platform.gradle.tasks.PrepareSandboxTask
 import software.aws.toolkits.gradle.changelog.tasks.GeneratePluginChangeLog
-import software.aws.toolkits.gradle.intellij.IdeFlavor
-import software.aws.toolkits.gradle.intellij.IdeVersions
-import software.aws.toolkits.gradle.intellij.toolkitIntelliJ
 
 plugins {
     id("toolkit-publishing-conventions")
     id("toolkit-publish-root-conventions")
     id("toolkit-jvm-conventions")
     id("toolkit-testing")
+    id("de.undercouch.download")
+}
+
+buildscript {
+    dependencies {
+        classpath(libs.bundles.jackson)
+    }
 }
 
 val changelog = tasks.register<GeneratePluginChangeLog>("pluginChangeLog") {
@@ -51,3 +58,81 @@ tasks.check {
         }
     }
 }
+
+val downloadFlareManifest by tasks.registering(Download::class) {
+    src("https://aws-toolkit-language-servers.amazonaws.com/qAgenticChatServer/0/manifest.json")
+    dest(layout.buildDirectory.file("flare/manifest.json"))
+    onlyIfModified(true)
+    useETag(true)
+}
+
+data class FlareManifest(
+    val versions: List<FlareVersion>,
+)
+
+data class FlareVersion(
+    val serverVersion: String,
+    val thirdPartyLicenses: String,
+    val targets: List<FlareTarget>,
+)
+
+data class FlareTarget(
+    val platform: String,
+    val arch: String,
+    val contents: List<FlareContent>
+)
+
+data class FlareContent(
+    val url: String,
+)
+
+val downloadFlareArtifacts by tasks.registering(Download::class) {
+    dependsOn(downloadFlareManifest)
+    inputs.files(downloadFlareManifest)
+
+    val manifestFile = downloadFlareManifest.map { it.outputFiles.first() }
+    val manifest = manifestFile.map { jacksonObjectMapper().disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES).readValue(it.readText(), FlareManifest::class.java) }
+
+    // use darwin-aarch64 because its the smallest and we're going to throw away everything platform specific
+    val latest = manifest.map { it.versions.first() }
+    val latestVersion = latest.map { it.serverVersion }
+    val licensesUrl = latest.map { it.thirdPartyLicenses }
+    val darwin = latest.map { it.targets.first { it.platform == "darwin" && it.arch == "arm64" } }
+    val contentUrls = darwin.map { it.contents.map { content -> content.url } }
+
+    val destination = layout.buildDirectory.dir(latestVersion.map { "flare/$it" })
+    outputs.dir(destination)
+
+    src(contentUrls.zip(licensesUrl) { left, right -> left + right})
+    dest(destination)
+    onlyIfModified(true)
+    useETag(true)
+}
+
+val prepareBundledFlare by tasks.registering(Copy::class) {
+    dependsOn(downloadFlareArtifacts)
+    inputs.files(downloadFlareArtifacts)
+
+    val dest = layout.buildDirectory.dir("tmp/extractFlare")
+    into(dest)
+
+    from(downloadFlareArtifacts.map { it.outputFiles.filterNot { it.name.endsWith(".zip") } })
+    doLast {
+        copy {
+            into(dest)
+            includeEmptyDirs = false
+            downloadFlareArtifacts.get().outputFiles.filter { it.name.endsWith(".zip") }.forEach {
+                dest.get().file(it.parentFile.name).asFile.createNewFile()
+                from(zipTree(it)) {
+                    include("*.js")
+                    include("*.txt")
+                }
+            }
+        }
+    }
+}
+
+tasks.withType<PrepareSandboxTask>().configureEach {
+    intoChild(intellijPlatform.projectName.map { "$it/flare" })
+        .from(prepareBundledFlare)
+}

plugins/amazonq/shared/jetbrains-community/build.gradle.kts

@@ -24,3 +24,12 @@ dependencies {
 
     testFixturesApi(testFixtures(project(":plugin-core:jetbrains-community")))
 }
+
+// hack because our test structure currently doesn't make complete sense
+tasks.prepareTestSandbox {
+    val pluginXmlJar = project(":plugin-amazonq").tasks.jar
+
+    dependsOn(pluginXmlJar)
+    intoChild(intellijPlatform.projectName.map { "$it/lib" })
+        .from(pluginXmlJar)
+}

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

@@ -16,6 +16,9 @@ import org.jetbrains.annotations.VisibleForTesting
 import software.aws.toolkits.core.utils.error
 import software.aws.toolkits.core.utils.getLogger
 import software.aws.toolkits.core.utils.info
+import software.aws.toolkits.core.utils.warn
+import software.aws.toolkits.jetbrains.AwsPlugin
+import software.aws.toolkits.jetbrains.AwsToolkit
 import java.nio.file.Path
 
 @Service
@@ -54,36 +57,43 @@ class ArtifactManager @NonInjectable internal constructor(private val manifestFe
         return mutex.withLock {
             coroutineScope {
                 async {
-                    val manifest = manifestFetcher.fetch() ?: throw LspException(
-                        "Language Support is not available, as manifest is missing.",
-                        LspException.ErrorCode.MANIFEST_FETCH_FAILED
-                    )
-                    val lspVersions = getLSPVersionsFromManifestWithSpecifiedRange(manifest)
-
-                    artifactHelper.removeDelistedVersions(lspVersions.deListedVersions)
-
-                    if (lspVersions.inRangeVersions.isEmpty()) {
-                        // No versions are found which are in the given range. Fallback to local lsp artifacts.
-                        val localLspArtifacts = artifactHelper.getAllLocalLspArtifactsWithinManifestRange(DEFAULT_VERSION_RANGE)
-                        if (localLspArtifacts.isNotEmpty()) {
-                            return@async localLspArtifacts.first().first
+                    try {
+                        val manifest = manifestFetcher.fetch() ?: throw LspException(
+                            "Language Support is not available, as manifest is missing.",
+                            LspException.ErrorCode.MANIFEST_FETCH_FAILED
+                        )
+                        val lspVersions = getLSPVersionsFromManifestWithSpecifiedRange(manifest)
+
+                        artifactHelper.removeDelistedVersions(lspVersions.deListedVersions)
+
+                        if (lspVersions.inRangeVersions.isEmpty()) {
+                            // No versions are found which are in the given range. Fallback to local lsp artifacts.
+                            val localLspArtifacts = artifactHelper.getAllLocalLspArtifactsWithinManifestRange(DEFAULT_VERSION_RANGE)
+                            if (localLspArtifacts.isNotEmpty()) {
+                                return@async localLspArtifacts.first().first
+                            }
+                            throw LspException("Language server versions not found in manifest.", LspException.ErrorCode.NO_COMPATIBLE_LSP_VERSION)
                         }
-                        throw LspException("Language server versions not found in manifest.", LspException.ErrorCode.NO_COMPATIBLE_LSP_VERSION)
-                    }
 
-                    val targetVersion = lspVersions.inRangeVersions.first()
+                        val targetVersion = lspVersions.inRangeVersions.first()
 
-                    // If there is an LSP Manifest with the same version
-                    val target = getTargetFromLspManifest(targetVersion)
-                    // Get Local LSP files and check if we can re-use existing LSP Artifacts
-                    val artifactPath: Path = if (artifactHelper.getExistingLspArtifacts(targetVersion, target)) {
-                        artifactHelper.getAllLocalLspArtifactsWithinManifestRange(DEFAULT_VERSION_RANGE).first().first
-                    } else {
-                        artifactHelper.tryDownloadLspArtifacts(project, targetVersion, target)
-                            ?: throw LspException("Failed to download LSP artifacts", LspException.ErrorCode.DOWNLOAD_FAILED)
+                        // If there is an LSP Manifest with the same version
+                        val target = getTargetFromLspManifest(targetVersion)
+                        // Get Local LSP files and check if we can re-use existing LSP Artifacts
+                        val artifactPath: Path = if (artifactHelper.getExistingLspArtifacts(targetVersion, target)) {
+                            artifactHelper.getAllLocalLspArtifactsWithinManifestRange(DEFAULT_VERSION_RANGE).first().first
+                        } else {
+                            artifactHelper.tryDownloadLspArtifacts(project, targetVersion, target)
+                                ?: throw LspException("Failed to download LSP artifacts", LspException.ErrorCode.DOWNLOAD_FAILED)
+                        }
+                        artifactHelper.deleteOlderLspArtifacts(DEFAULT_VERSION_RANGE)
+                        return@async artifactPath
+                    } catch(e: Exception) {
+                        logger.warn(e) { "Failed to resolve assets from Flare CDN" }
+                        val path = AwsToolkit.PLUGINS_INFO[AwsPlugin.Q]?.path?.resolve("flare") ?: error("not even bundled")
+                        logger.info { "Falling back to bundled assets at $path" }
+                        return@async path
                     }
-                    artifactHelper.deleteOlderLspArtifacts(DEFAULT_VERSION_RANGE)
-                    return@async artifactPath
                 }
             }.also {
                 artifactDeferred = it

plugins/amazonq/shared/jetbrains-community/tst/software/aws/toolkits/jetbrains/services/amazonq/lsp/artifacts/ArtifactManagerTest.kt

@@ -3,6 +3,8 @@
 
 package software.aws.toolkits.jetbrains.services.amazonq.lsp.artifacts
 
+import com.intellij.ide.plugins.PluginManagerCore
+import com.intellij.openapi.extensions.PluginId
 import com.intellij.testFramework.ProjectExtension
 import com.intellij.util.text.SemVer
 import io.mockk.Runs
@@ -51,29 +53,31 @@ class ArtifactManagerTest {
     }
 
     @Test
-    fun `fetch artifact fetcher throws exception if manifest is null`() = runTest {
+    fun `fetch artifact fetcher returns bundled if manifest is null`() = runTest {
         every { manifestFetcher.fetch() }.returns(null)
 
         val exception = assertThrows<LspException> {
             artifactManager.fetchArtifact(projectExtension.project)
         }
-        assertThat(exception)
-            .hasFieldOrPropertyWithValue("errorCode", LspException.ErrorCode.MANIFEST_FETCH_FAILED)
+
+        assertThat(artifactManager.fetchArtifact(projectExtension.project))
+            .isEqualTo(
+                PluginManagerCore.getPlugin(PluginId.getId("amazon.q"))?.pluginPath?.resolve("flare")
+            )
     }
 
     @Test
-    fun `fetch artifact does not have any valid lsp versions`() = runTest {
+    fun `fetch artifact does not have any valid lsp versions returns bundled`() = runTest {
         every { manifestFetcher.fetch() }.returns(Manifest())
 
         every { artifactManager.getLSPVersionsFromManifestWithSpecifiedRange(any()) }.returns(
             ArtifactManager.LSPVersions(deListedVersions = emptyList(), inRangeVersions = emptyList())
         )
 
-        val exception = assertThrows<LspException> {
-            artifactManager.fetchArtifact(projectExtension.project)
-        }
-        assertThat(exception)
-            .hasFieldOrPropertyWithValue("errorCode", LspException.ErrorCode.NO_COMPATIBLE_LSP_VERSION)
+        assertThat(artifactManager.fetchArtifact(projectExtension.project))
+            .isEqualTo(
+                PluginManagerCore.getPlugin(PluginId.getId("amazon.q"))?.pluginPath?.resolve("flare")
+            )
     }
 
     @Test

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

@@ -4,11 +4,11 @@
 package software.aws.toolkits.jetbrains
 
 import com.intellij.ide.plugins.PluginManagerCore
 import com.intellij.openapi.application.ApplicationManager
 import com.intellij.openapi.extensions.PluginDescriptor
 import com.intellij.openapi.extensions.PluginId
 import java.nio.file.Path
 import java.nio.file.Paths
 import java.util.EnumMap
 
 object AwsToolkit {
@@ -37,12 +37,7 @@
     val version: String?
         get() = descriptor?.version
     val path: Path?
-        get() =
-            if (ApplicationManager.getApplication().isUnitTestMode) {
-                Paths.get(System.getProperty("plugin.path"))
-            } else {
-                descriptor?.pluginPath
-            }
+        get() = descriptor?.pluginPath
 }
 
 enum class AwsPlugin {