Merge branch 'feature/q-lsp-chat' into rli/artifact-fallback

Author: rli

plugins/amazonq/build.gradle.kts

@@ -97,7 +97,7 @@ val downloadFlareArtifacts by tasks.registering(Download::class) {
     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 darwin = latest.map { it.targets.first { target -> target.platform == "darwin" && target.arch == "arm64" } }
     val contentUrls = darwin.map { it.contents.map { content -> content.url } }
 
     val destination = layout.buildDirectory.dir(latestVersion.map { "flare/$it" })
@@ -115,8 +115,8 @@ val prepareBundledFlare by tasks.registering(Copy::class) {
 
     val dest = layout.buildDirectory.dir("tmp/extractFlare")
     into(dest)
+    from(downloadFlareArtifacts.map { it.outputFiles.filterNot { file -> file.name.endsWith(".zip") } })
 
-    from(downloadFlareArtifacts.map { it.outputFiles.filterNot { it.name.endsWith(".zip") } })
     doLast {
         copy {
             into(dest)

plugins/amazonq/chat/jetbrains-community/src/software/aws/toolkits/jetbrains/services/amazonq/webview/BrowserConnector.kt

@@ -41,6 +41,7 @@ import software.aws.toolkits.jetbrains.services.amazonq.lsp.JsonRpcNotification
 import software.aws.toolkits.jetbrains.services.amazonq.lsp.JsonRpcRequest
 import software.aws.toolkits.jetbrains.services.amazonq.lsp.encryption.JwtEncryptionManager
 import software.aws.toolkits.jetbrains.services.amazonq.lsp.flareChat.AwsServerCapabilitiesProvider
+import software.aws.toolkits.jetbrains.services.amazonq.lsp.flareChat.ChatAsyncResultManager
 import software.aws.toolkits.jetbrains.services.amazonq.lsp.flareChat.ChatCommunicationManager
 import software.aws.toolkits.jetbrains.services.amazonq.lsp.flareChat.FlareUiMessage
 import software.aws.toolkits.jetbrains.services.amazonq.lsp.model.aws.chat.AUTH_FOLLOW_UP_CLICKED
@@ -106,6 +107,7 @@ class BrowserConnector(
 ) {
     var uiReady = CompletableDeferred<Boolean>()
     private val chatCommunicationManager = ChatCommunicationManager.getInstance(project)
+    private val chatAsyncResultManager = ChatAsyncResultManager.getInstance(project)
 
     suspend fun connect(
         browser: Browser,
@@ -227,6 +229,7 @@ class BrowserConnector(
 
                 val tabId = requestFromUi.params.tabId
                 val partialResultToken = chatCommunicationManager.addPartialChatMessage(tabId)
+                chatCommunicationManager.registerPartialResultToken(partialResultToken)
 
                 var encryptionManager: JwtEncryptionManager? = null
                 val result = AmazonQLspService.executeIfRunning(project) { server ->
@@ -247,6 +250,7 @@ class BrowserConnector(
                 val tabId = requestFromUi.params.tabId
                 val quickActionParams = node.params ?: error("empty payload")
                 val partialResultToken = chatCommunicationManager.addPartialChatMessage(tabId)
+                chatCommunicationManager.registerPartialResultToken(partialResultToken)
                 var encryptionManager: JwtEncryptionManager? = null
                 val result = AmazonQLspService.executeIfRunning(project) { server ->
                     encryptionManager = this.encryptionManager
@@ -476,15 +480,32 @@ class BrowserConnector(
                 )
                 browser.postChat(messageToChat)
                 chatCommunicationManager.removeInflightRequestForTab(tabId)
-            } catch (_: CancellationException) {
+            } catch (e: CancellationException) {
                 LOG.warn { "Cancelled chat generation" }
+                try {
+                    chatAsyncResultManager.createRequestId(partialResultToken)
+                    chatAsyncResultManager.getResult(partialResultToken)
+                    handleCancellation(tabId, browser)
+                } catch (ex: Exception) {
+                    LOG.warn(ex) { "An error occurred while processing cancellation" }
+                } finally {
+                    chatAsyncResultManager.removeRequestId(partialResultToken)
+                    chatCommunicationManager.removePartialResultLock(partialResultToken)
+                    chatCommunicationManager.removeFinalResultProcessed(partialResultToken)
+                }
             } catch (e: Exception) {
                 LOG.warn(e) { "Failed to send chat message" }
                 browser.postChat(chatCommunicationManager.getErrorUiMessage(tabId, e, partialResultToken))
             }
         }
     }
 
+    private fun handleCancellation(tabId: String, browser: Browser) {
+        // Send a message to hide the stop button without showing an error
+        val cancelMessage = chatCommunicationManager.getCancellationUiMessage(tabId)
+        browser.postChat(cancelMessage)
+    }
+
     private fun cancelInflightRequests(tabId: String) {
         chatCommunicationManager.getInflightRequestForTab(tabId)?.let { request ->
             request.cancel(true)

plugins/amazonq/chat/jetbrains-community/src/software/aws/toolkits/jetbrains/services/amazonq/webview/theme/AmazonQTheme.kt

@@ -16,6 +16,8 @@ data class AmazonQTheme(
     val defaultText: Color,
     val inactiveText: Color,
     val linkText: Color,
+    val lightText: Color,
+    val emptyText: Color,
 
     val background: Color,
     val border: Color,
@@ -31,6 +33,8 @@ data class AmazonQTheme(
     val buttonBackground: Color,
     val secondaryButtonForeground: Color,
     val secondaryButtonBackground: Color,
+    val inputBorderFocused: Color,
+    val inputBorderUnfocused: Color,
 
     val info: Color,
     val success: Color,

plugins/amazonq/chat/jetbrains-community/src/software/aws/toolkits/jetbrains/services/amazonq/webview/theme/CssVariable.kt

@@ -16,6 +16,7 @@ enum class CssVariable(
     TextColorAlt("--mynah-color-text-alternate"),
     TextColorStrong("--mynah-color-text-strong"),
     TextColorWeak("--mynah-color-text-weak"),
+    TextColorLight("--mynah-color-light"),
     TextColorLink("--mynah-color-text-link"),
     TextColorInput("--mynah-color-text-input"),
     TextColorDisabled("--mynah-color-text-disabled"),
@@ -27,6 +28,8 @@ enum class CssVariable(
     ColorDeep("--mynah-color-deep"),
     ColorDeepReverse("--mynah-color-deep-reverse"),
     BorderDefault("--mynah-color-border-default"),
+    BorderFocused("--mynah-color-text-input-border-focused"),
+    BorderUnfocused("--mynah-color-text-input-border"),
     InputBackground("--mynah-input-bg"),
 
     SyntaxBackground("--mynah-color-syntax-bg"),

plugins/amazonq/chat/jetbrains-community/src/software/aws/toolkits/jetbrains/services/amazonq/webview/theme/EditorThemeAdapter.kt

@@ -124,6 +124,10 @@ class EditorThemeAdapter {
                 editorString = currentScheme.foregroundColor(DefaultLanguageHighlighterColors.STRING),
                 editorProperty = currentScheme.foregroundColor(DefaultLanguageHighlighterColors.INSTANCE_FIELD),
                 editorClassName = currentScheme.foregroundColor(DefaultLanguageHighlighterColors.CLASS_NAME),
+                lightText = themeColor("TextField.inactiveForeground", default = 0xA8ADBD, darkDefault = 0x5A5D63),
+                emptyText = themeColor("TextField.inactiveForeground", default = 0xA8ADBD, darkDefault = 0x5A5D63),
+                inputBorderFocused = themeColor("ActionButton.focusedBorderColor", default = 0x4682FA, darkDefault = 0x3574f0),
+                inputBorderUnfocused = themeColor("TextField.borderColor", default = 0xEBECF0, darkDefault = 0x4E5157),
             )
         }
 

plugins/amazonq/chat/jetbrains-community/src/software/aws/toolkits/jetbrains/services/amazonq/webview/theme/ThemeBrowserAdapter.kt

@@ -26,6 +26,7 @@ class ThemeBrowserAdapter {
     }
 
     private fun buildJsCodeToUpdateTheme(theme: AmazonQTheme) = buildString {
+        val (bg, altBg, inputBg) = determineInputAndBgColor(theme)
         appendDarkMode(theme.darkMode)
 
         append("{\n")
@@ -39,17 +40,20 @@ class ThemeBrowserAdapter {
         append(CssVariable.TextColorStrong, theme.textFieldForeground)
         append(CssVariable.TextColorInput, theme.textFieldForeground)
         append(CssVariable.TextColorLink, theme.linkText)
-        append(CssVariable.TextColorWeak, theme.inactiveText)
+        append(CssVariable.TextColorWeak, theme.emptyText)
+        append(CssVariable.TextColorLight, theme.emptyText)
         append(CssVariable.TextColorDisabled, theme.inactiveText)
 
-        append(CssVariable.Background, theme.editorBackground)
-        append(CssVariable.BackgroundAlt, theme.background)
-        append(CssVariable.CardBackground, theme.editorBackground)
-        append(CssVariable.CardBackgroundAlt, theme.background)
+        append(CssVariable.Background, bg)
+        append(CssVariable.BackgroundAlt, altBg)
+        append(CssVariable.CardBackground, bg)
+        append(CssVariable.CardBackgroundAlt, altBg)
         append(CssVariable.BorderDefault, theme.border)
+        append(CssVariable.BorderFocused, theme.inputBorderFocused)
+        append(CssVariable.BorderUnfocused, theme.inputBorderUnfocused)
         append(CssVariable.TabActive, theme.activeTab)
 
-        append(CssVariable.InputBackground, theme.textFieldBackground)
+        append(CssVariable.InputBackground, inputBg)
 
         append(CssVariable.ButtonBackground, theme.buttonBackground)
         append(CssVariable.ButtonForeground, theme.buttonForeground)
@@ -110,4 +114,15 @@ class ThemeBrowserAdapter {
 
     // Some font names have characters that require them to be wrapped in quotes in the CSS variable, for example if they have spaces or a period.
     private fun Font.toCssFontFamily(fallback: String = "system-ui") = "\"$family\", $fallback"
+
+    // darkest = bg, second darkest is alt bg, lightest is input bg
+    private fun determineInputAndBgColor(theme: AmazonQTheme): Triple<Color, Color, Color> {
+        val colors = arrayOf(theme.editorBackground, theme.background, theme.textFieldBackground).sortedWith(
+            Comparator.comparing {
+                // luma calculation for brightness
+                (0.2126 * it.red) + (0.7152 * it.green) + (0.0722 * it.blue)
+            }
+        )
+        return Triple(colors[0], colors[1], colors[2])
+    }
 }

plugins/amazonq/codewhisperer/jetbrains-community/src/software/aws/toolkits/jetbrains/services/codewhisperer/settings/CodeWhispererConfigurable.kt

@@ -83,6 +83,21 @@ class CodeWhispererConfigurable(private val project: Project) :
                     .resizableColumn()
                     .align(Align.FILL)
             }
+            row(message("amazonqFeatureDev.placeholder.node_runtime_path")) {
+                val fileChooserDescriptor = FileChooserDescriptorFactory.createSingleFileDescriptor()
+                fileChooserDescriptor.isForcedToUseIdeaFileChooser = true
+
+                textFieldWithBrowseButton(fileChooserDescriptor = fileChooserDescriptor)
+                    .bindText(
+                        { LspSettings.getInstance().getNodeRuntimePath().orEmpty() },
+                        { LspSettings.getInstance().setNodeRuntimePath(it) }
+                    )
+                    .applyToComponent {
+                        emptyText.text = message("executableCommon.auto_managed")
+                    }
+                    .resizableColumn()
+                    .align(Align.FILL)
+            }
         }
 
         group(message("aws.settings.codewhisperer.group.general")) {

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

@@ -5,16 +5,19 @@ package software.aws.toolkits.jetbrains.services.amazonq.lsp
 
 import com.google.gson.ToNumberPolicy
 import com.intellij.execution.configurations.GeneralCommandLine
+import com.intellij.execution.configurations.PathEnvironmentVariableUtil
 import com.intellij.execution.impl.ExecutionManagerImpl
 import com.intellij.execution.process.KillableColoredProcessHandler
 import com.intellij.execution.process.KillableProcessHandler
 import com.intellij.execution.process.ProcessEvent
 import com.intellij.execution.process.ProcessListener
 import com.intellij.execution.process.ProcessOutputType
+import com.intellij.notification.NotificationAction
 import com.intellij.openapi.Disposable
 import com.intellij.openapi.components.Service
 import com.intellij.openapi.components.service
 import com.intellij.openapi.components.serviceIfCreated
+import com.intellij.openapi.options.ShowSettingsUtil
 import com.intellij.openapi.project.Project
 import com.intellij.openapi.util.Disposer
 import com.intellij.openapi.util.Key
@@ -76,6 +79,8 @@ import software.aws.toolkits.jetbrains.services.amazonq.lsp.workspace.WorkspaceS
 import software.aws.toolkits.jetbrains.services.amazonq.profile.QDefaultServiceConfig
 import software.aws.toolkits.jetbrains.services.telemetry.ClientMetadata
 import software.aws.toolkits.jetbrains.settings.LspSettings
+import software.aws.toolkits.jetbrains.utils.notifyInfo
+import software.aws.toolkits.resources.message
 import java.io.IOException
 import java.io.OutputStreamWriter
 import java.io.PipedInputStream
@@ -86,7 +91,9 @@ import java.net.Proxy
 import java.net.URI
 import java.nio.charset.StandardCharsets
 import java.nio.file.Files
+import java.nio.file.Path
 import java.util.concurrent.Future
+import java.util.concurrent.TimeUnit
 import kotlin.time.Duration.Companion.seconds
 
 // https://github.com/redhat-developer/lsp4ij/blob/main/src/main/java/com/redhat/devtools/lsp4ij/server/LSPProcessListener.java
@@ -372,7 +379,9 @@ private class AmazonQServerInstance(private val project: Project, private val cs
         }
 
         val node = if (SystemInfo.isWindows) "node.exe" else "node"
-        val cmd = NodeExePatcher.patch(artifact.resolve(node))
+        var nodePath = getNodeRuntimePath(artifact.resolve(node))
+
+        val cmd = NodeExePatcher.patch(nodePath)
             .withParameters(
                 LspSettings.getInstance().getArtifactPath() ?: artifact.resolve("aws-lsp-codewhisperer.js").toString(),
                 "--stdio",
@@ -492,6 +501,103 @@ private class AmazonQServerInstance(private val project: Project, private val cs
         }
     }
 
+    /**
+     * Resolves the path to a valid Node.js runtime in the following order of preference:
+     * 1. Uses the provided nodePath if it exists and is executable
+     * 2. Uses user-specified runtime path from LSP settings if available
+     * 3. Uses system Node.js if version 18+ is available
+     * 4. Falls back to original nodePath with a notification to configure runtime
+     *
+     * @param nodePath The initial Node.js runtime path to check, typically from the artifact directory
+     * @return Path The resolved Node.js runtime path to use for the LSP server
+     *
+     * Side effects:
+     * - Logs warnings if initial runtime path is invalid
+     * - Logs info when using alternative runtime path
+     * - Shows notification to user if no valid Node.js runtime is found
+     *
+     * Note: The function will return a path even if no valid runtime is found, but the LSP server
+     * may fail to start in that case. The caller should handle potential runtime initialization failures.
+     */
+    private fun getNodeRuntimePath(nodePath: Path): Path {
+        if (Files.exists(nodePath) && Files.isExecutable(nodePath)) {
+            return nodePath
+        }
+        // use alternative node runtime if it is not found
+        LOG.warn { "Node Runtime download failed. Fallback to user specified node runtime " }
+        // attempt to use user provided node runtime path
+        val nodeRuntime = LspSettings.getInstance().getNodeRuntimePath()
+        if (!nodeRuntime.isNullOrEmpty()) {
+            LOG.info { "Using node from $nodeRuntime " }
+            return Path.of(nodeRuntime)
+        } else {
+            val localNode = locateNodeCommand()
+            if (localNode != null) {
+                LOG.info { "Using node from ${localNode.toAbsolutePath()}" }
+                return localNode
+            }
+            notifyInfo(
+                "Amazon Q",
+                message("amazonqFeatureDev.placeholder.node_runtime_message"),
+                project = project,
+                listOf(
+                    NotificationAction.create(
+                        message("codewhisperer.actions.open_settings.title")
+                    ) { _, notification ->
+                        ShowSettingsUtil.getInstance().showSettingsDialog(project, message("aws.settings.codewhisperer.configurable.title"))
+                    },
+                    NotificationAction.create(
+                        message("codewhisperer.notification.custom.simple.button.got_it")
+                    ) { _, notification -> notification.expire() }
+                )
+            )
+            return nodePath
+        }
+    }
+
+    /**
+     * Locates node executable ≥18 in system PATH.
+     * Uses IntelliJ's PathEnvironmentVariableUtil to find executables.
+     *
+     * @return Path? The absolute path to node ≥18 if found, null otherwise
+     */
+    private fun locateNodeCommand(): Path? {
+        val exeName = if (SystemInfo.isWindows) "node.exe" else "node"
+
+        return PathEnvironmentVariableUtil.findAllExeFilesInPath(exeName)
+            .asSequence()
+            .map { it.toPath() }
+            .filter { Files.isRegularFile(it) && Files.isExecutable(it) }
+            .firstNotNullOfOrNull { path ->
+                try {
+                    val process = ProcessBuilder(path.toString(), "--version")
+                        .redirectErrorStream(true)
+                        .start()
+
+                    if (!process.waitFor(5, TimeUnit.SECONDS)) {
+                        process.destroy()
+                        null
+                    } else if (process.exitValue() == 0) {
+                        val version = process.inputStream.bufferedReader().readText().trim()
+                        val majorVersion = version.removePrefix("v").split(".")[0].toIntOrNull()
+
+                        if (majorVersion != null && majorVersion >= 18) {
+                            path.toAbsolutePath()
+                        } else {
+                            LOG.debug { "Node version < 18 found at: $path (version: $version)" }
+                            null
+                        }
+                    } else {
+                        LOG.debug { "Failed to get version from node at: $path" }
+                        null
+                    }
+                } catch (e: Exception) {
+                    LOG.debug(e) { "Failed to check version for node at: $path" }
+                    null
+                }
+            }
+    }
+
     override fun dispose() {
         if (!launcherFuture.isDone) {
             try {