Merge main into feature/bid-paid

.changes/3.74.json

@@ -0,0 +1,11 @@
+{
+  "date" : "2025-06-05",
+  "version" : "3.74",
+  "entries" : [ {
+    "type" : "feature",
+    "description" : "Agentic coding experience: Amazon Q can now write code and run shell commands on your behalf"
+  }, {
+    "type" : "bugfix",
+    "description" : "Support full Unicode range in inline chat panel on Windows"
+  } ]
+}

CHANGELOG.md

@@ -1,3 +1,7 @@
+# _3.74_ (2025-06-05)
+- **(Feature)** Agentic coding experience: Amazon Q can now write code and run shell commands on your behalf
+- **(Bug Fix)** Support full Unicode range in inline chat panel on Windows
+
 # _3.73_ (2025-05-29)
 - **(Bug Fix)** /transform: handle InvalidGrantException properly when polling job status
 

gradle.properties

@@ -2,7 +2,7 @@
 # SPDX-License-Identifier: Apache-2.0
 
 # Toolkit Version
-toolkitVersion=3.74-SNAPSHOT
+toolkitVersion=3.75-SNAPSHOT
 
 # Publish Settings
 publishToken=

plugins/amazonq/chat/jetbrains-community/src/software/aws/toolkits/jetbrains/services/amazonq/toolwindow/AmazonQPanel.kt

@@ -25,6 +25,7 @@
 import software.aws.toolkits.jetbrains.services.amazonq.apps.AmazonQAppInitContext
 import software.aws.toolkits.jetbrains.services.amazonq.apps.AppConnection
 import software.aws.toolkits.jetbrains.services.amazonq.commands.MessageTypeRegistry
+import software.aws.toolkits.jetbrains.services.amazonq.isQSupportedInThisVersion
 import software.aws.toolkits.jetbrains.services.amazonq.lsp.AmazonQLspService
 import software.aws.toolkits.jetbrains.services.amazonq.lsp.flareChat.AsyncChatUiListener
 import software.aws.toolkits.jetbrains.services.amazonq.lsp.flareChat.FlareUiMessage
@@ -41,6 +42,7 @@
 import software.aws.toolkits.jetbrains.services.amazonqDoc.auth.isDocAvailable
 import software.aws.toolkits.jetbrains.services.amazonqFeatureDev.auth.isFeatureDevAvailable
 import software.aws.toolkits.jetbrains.services.codemodernizer.utils.isCodeTransformAvailable
+import software.aws.toolkits.resources.message
 import java.nio.file.Paths
 import java.util.concurrent.CompletableFuture
 import javax.swing.JButton
@@ -102,6 +104,9 @@
                 webviewContainer.add(JBTextArea("JCEF not supported"))
             }
             browser.complete(null)
+        } else if (!isQSupportedInThisVersion()) {
+            webviewContainer.add(JBTextArea("${message("q.unavailable")}\n ${message("q.unavailable.node")}"))
+            browser.complete(null)
         } else {
             val loadingPanel = JBLoadingPanel(null, this)
             val wrapper = Wrapper()

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

@@ -224,7 +224,7 @@
                 )
 
                 val serializedEnrichmentParams = serializer.objectMapper.valueToTree<ObjectNode>(enrichmentParams)
-                val chatParams: ObjectNode = (node as ObjectNode)
+                val chatParams: ObjectNode = (node.params as ObjectNode)
                     .setAll(serializedEnrichmentParams)
 
                 val tabId = requestFromUi.params.tabId
@@ -235,7 +235,7 @@
                 val result = AmazonQLspService.executeIfRunning(project) { server ->
                     encryptionManager = this.encryptionManager
 
-                    val encryptedParams = EncryptedChatParams(this.encryptionManager.encrypt(chatParams.params), partialResultToken)
+                    val encryptedParams = EncryptedChatParams(this.encryptionManager.encrypt(chatParams), partialResultToken)
                     rawEndpoint.request(SEND_CHAT_COMMAND_PROMPT, encryptedParams) as CompletableFuture<String>
                 } ?: (CompletableFuture.failedFuture(IllegalStateException("LSP Server not running")))
 

plugins/amazonq/chat/jetbrains-community/src/software/aws/toolkits/jetbrains/services/cwc/commands/ActionRegistrar.kt

@@ -29,7 +29,7 @@
 
     fun reportMessageClick(command: EditorContextCommand, project: Project) {
         if (command == EditorContextCommand.GenerateUnitTests) {
-            AsyncChatUiListener.notifyPartialMessageUpdate(Gson().toJson(TestCommandMessage()))
+            AsyncChatUiListener.notifyPartialMessageUpdate(project, Gson().toJson(TestCommandMessage()))
         } else {
             // new agentic chat route
             ApplicationManager.getApplication().executeOnPooledThread {
@@ -45,7 +45,7 @@
                         val params = SendToPromptParams(selection = codeSelection, triggerType = TriggerType.CONTEXT_MENU)
                         uiMessage = FlareUiMessage(command = SEND_TO_PROMPT, params = params)
                     }
-                    AsyncChatUiListener.notifyPartialMessageUpdate(uiMessage)
+                    AsyncChatUiListener.notifyPartialMessageUpdate(project, uiMessage)
                 }
             }
         }

plugins/amazonq/chat/jetbrains-community/src/software/aws/toolkits/jetbrains/services/cwc/commands/codescan/actions/ExplainCodeIssueAction.kt

@@ -4,6 +4,7 @@
 package software.aws.toolkits.jetbrains.services.cwc.commands.codescan.actions
 
 import com.intellij.openapi.actionSystem.ActionManager
+import com.intellij.openapi.actionSystem.ActionUpdateThread
 import com.intellij.openapi.actionSystem.AnAction
 import com.intellij.openapi.actionSystem.AnActionEvent
 import com.intellij.openapi.actionSystem.DataKey
@@ -18,7 +19,14 @@
 import software.aws.toolkits.jetbrains.services.amazonq.lsp.model.aws.chat.TriggerType
 
 class ExplainCodeIssueAction : AnAction(), DumbAware {
+    override fun getActionUpdateThread() = ActionUpdateThread.BGT
+
+    override fun update(e: AnActionEvent) {
+        e.presentation.isEnabledAndVisible = e.project != null
+    }
+
     override fun actionPerformed(e: AnActionEvent) {
+        val project = e.project ?: return
         val issueDataKey = DataKey.create<MutableMap<String, String>>("amazonq.codescan.explainissue")
         val issueContext = e.getData(issueDataKey) ?: return
 
@@ -50,7 +58,7 @@
                 )
 
                 val uiMessage = FlareUiMessage(SEND_TO_PROMPT, params)
-                AsyncChatUiListener.notifyPartialMessageUpdate(uiMessage)
+                AsyncChatUiListener.notifyPartialMessageUpdate(project, uiMessage)
             }
         }
     }

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

@@ -3,7 +3,9 @@
 
 package software.aws.toolkits.jetbrains.services.amazonq
 
+import com.intellij.openapi.application.ApplicationInfo
 import com.intellij.openapi.project.Project
+import com.intellij.openapi.util.BuildNumber
 import com.intellij.openapi.util.SystemInfo
 import software.amazon.awssdk.services.codewhispererruntime.model.IdeCategory
 import software.amazon.awssdk.services.codewhispererruntime.model.OperatingSystem
@@ -52,3 +54,12 @@
         .ideVersion(it.awsVersion)
         .build()
 }
+
+fun isQSupportedInThisVersion(): Boolean {
+    val currentBuild = ApplicationInfo.getInstance().build.withoutProductCode()
+
+    return !(
+        currentBuild.baselineVersion == 242 &&
+            BuildNumber.fromString("242.22855.74")?.let { currentBuild < it } == true
+        )
+}

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

@@ -158,18 +158,21 @@
             // The filepath sent by the server contains unicode characters which need to be
             // decoded for JB file handling APIs to be handle to handle file operations
             val fileToOpen = URLDecoder.decode(params.uri, StandardCharsets.UTF_8.name())
-            ApplicationManager.getApplication().invokeLater {
-                try {
-                    val virtualFile = VirtualFileManager.getInstance().findFileByUrl(fileToOpen)
-                        ?: throw IllegalArgumentException("Cannot find file: $fileToOpen")
-
-                    FileEditorManager.getInstance(project).openFile(virtualFile, true)
-                } catch (e: Exception) {
-                    LOG.warn { "Failed to show document: $fileToOpen" }
-                }
-            }
+            return CompletableFuture.supplyAsync(
+                {
+                    try {
+                        val virtualFile = VirtualFileManager.getInstance().refreshAndFindFileByUrl(fileToOpen)
+                            ?: throw IllegalArgumentException("Cannot find file: $fileToOpen")
 
-            return CompletableFuture.completedFuture(ShowDocumentResult(true))
+                        FileEditorManager.getInstance(project).openFile(virtualFile, true)
+                        ShowDocumentResult(true)
+                    } catch (e: Exception) {
+                        LOG.warn { "Failed to show document: $fileToOpen" }
+                        ShowDocumentResult(false)
+                    }
+                },
+                ApplicationManager.getApplication()::invokeLater
+            )
         } catch (e: Exception) {
             LOG.warn { "Error showing document" }
             return CompletableFuture.completedFuture(ShowDocumentResult(false))
@@ -312,6 +315,7 @@
 
     override fun sendChatUpdate(params: LSPAny): CompletableFuture<Unit> {
         AsyncChatUiListener.notifyPartialMessageUpdate(
+            project,
             FlareUiMessage(
                 command = CHAT_SEND_UPDATE,
                 params = params,

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

@@ -78,10 +78,12 @@
 import software.aws.toolkits.jetbrains.services.amazonq.lsp.util.WorkspaceFolderUtil.createWorkspaceFolders
 import software.aws.toolkits.jetbrains.services.amazonq.lsp.workspace.WorkspaceServiceHandler
 import software.aws.toolkits.jetbrains.services.amazonq.profile.QDefaultServiceConfig
+import software.aws.toolkits.jetbrains.services.cwc.controller.chat.telemetry.getStartUrl
 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 software.aws.toolkits.telemetry.Telemetry
 import java.io.IOException
 import java.io.OutputStreamWriter
 import java.io.PipedInputStream
@@ -528,20 +530,36 @@
      * may fail to start in that case. The caller should handle potential runtime initialization failures.
      */
     private fun getNodeRuntimePath(nodePath: Path): Path {
+        val resolveNodeMetric = { isBundled: Boolean, success: Boolean ->
+            Telemetry.languageserver.setup.use {
+                it.id("q")
+                it.metadata("languageServerSetupStage", "resolveNode")
+                it.metadata("credentialStartUrl", getStartUrl(project))
+                it.setAttribute("isBundledNode", isBundled)
+                it.success(success)
+            }
+        }
+
         if (Files.exists(nodePath) && Files.isExecutable(nodePath)) {
+            resolveNodeMetric(true, true)
             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 " }
+
+            resolveNodeMetric(false, true)
             return Path.of(nodeRuntime)
         } else {
             val localNode = locateNodeCommand()
             if (localNode != null) {
                 LOG.info { "Using node from ${localNode.toAbsolutePath()}" }
+
+                resolveNodeMetric(false, true)
                 return localNode
             }
             notifyInfo(
@@ -559,6 +577,8 @@
                     ) { _, notification -> notification.expire() }
                 )
             )
+
+            resolveNodeMetric(false, false)
             return nodePath
         }
     }

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

@@ -17,7 +17,10 @@
 import software.aws.toolkits.core.utils.info
 import software.aws.toolkits.core.utils.warn
 import software.aws.toolkits.jetbrains.core.saveFileFromUrl
+import software.aws.toolkits.jetbrains.services.cwc.controller.chat.telemetry.getStartUrl
 import software.aws.toolkits.resources.AwsCoreBundle
+import software.aws.toolkits.telemetry.LanguageServerSetupStage
+import software.aws.toolkits.telemetry.Telemetry
 import java.nio.file.Files
 import java.nio.file.Path
 import java.nio.file.Paths
@@ -106,33 +109,33 @@
     }
 
     suspend fun tryDownloadLspArtifacts(project: Project, targetVersion: Version, target: VersionTarget): Path? {
-        val temporaryDownloadPath = Files.createTempDirectory("lsp-dl")
-        val downloadPath = lspArtifactsPath.resolve(targetVersion.serverVersion.toString())
+        val destinationPath = lspArtifactsPath.resolve(targetVersion.serverVersion.toString())
 
         while (currentAttempt.get() < maxDownloadAttempts) {
             currentAttempt.incrementAndGet()
             logger.info { "Attempt ${currentAttempt.get()} of $maxDownloadAttempts to download LSP artifacts" }
+            val temporaryDownloadPath = Files.createTempDirectory("lsp-dl")
 
             try {
                 return withBackgroundProgress(
                     project,
                     AwsCoreBundle.message("amazonqFeatureDev.placeholder.downloading_and_extracting_lsp_artifacts"),
                     cancellable = true
                 ) {
-                    if (downloadLspArtifacts(temporaryDownloadPath, target) && !target.contents.isNullOrEmpty()) {
-                        moveFilesFromSourceToDestination(temporaryDownloadPath, downloadPath)
+                    if (downloadLspArtifacts(project, temporaryDownloadPath, target) && !target.contents.isNullOrEmpty()) {
+                        moveFilesFromSourceToDestination(temporaryDownloadPath, destinationPath)
                         target.contents
                             .mapNotNull { it.filename }
-                            .forEach { filename -> extractZipFile(downloadPath.resolve(filename), downloadPath) }
-                        logger.info { "Successfully downloaded and moved LSP artifacts to $downloadPath" }
+                            .forEach { filename -> extractZipFile(destinationPath.resolve(filename), destinationPath) }
+                        logger.info { "Successfully downloaded and moved LSP artifacts to $destinationPath" }
 
                         val thirdPartyLicenses = targetVersion.thirdPartyLicenses
                         logger.info {
-                            "Installing Amazon Q Language Server v${targetVersion.serverVersion} to: $downloadPath. " +
+                            "Installing Amazon Q Language Server v${targetVersion.serverVersion} to: $destinationPath. " +
                                 if (thirdPartyLicenses == null) "" else "Attribution notice can be found at $thirdPartyLicenses"
                         }
 
-                        return@withBackgroundProgress downloadPath
+                        return@withBackgroundProgress destinationPath
                     }
 
                     return@withBackgroundProgress null
@@ -146,15 +149,15 @@
                     else -> { logger.error(e) { "Failed to download/move LSP artifacts on attempt ${currentAttempt.get()}" } }
                 }
                 temporaryDownloadPath.toFile().deleteRecursively()
-                downloadPath.toFile().deleteRecursively()
+                destinationPath.toFile().deleteRecursively()
             }
         }
         logger.error { "Failed to download LSP artifacts after $maxDownloadAttempts attempts" }
         return null
     }
 
     @VisibleForTesting
-    internal fun downloadLspArtifacts(downloadPath: Path, target: VersionTarget?): Boolean {
+    internal fun downloadLspArtifacts(project: Project, downloadPath: Path, target: VersionTarget?): Boolean {
         if (target == null || target.contents.isNullOrEmpty()) {
             logger.warn { "No target contents available for download" }
             return false
@@ -171,7 +174,7 @@
                     logger.warn { "No hash available for ${content.filename}" }
                     return@forEach
                 }
-                downloadAndValidateFile(content.url, filePath, contentHash)
+                downloadAndValidateFile(project, content.url, filePath, contentHash)
             }
             validateDownloadedFiles(downloadPath, target.contents)
         } catch (e: Exception) {
@@ -182,18 +185,46 @@
         return true
     }
 
-    private fun downloadAndValidateFile(url: String, filePath: Path, expectedHash: String) {
+    private fun downloadAndValidateFile(project: Project, url: String, filePath: Path, expectedHash: String) {
+        val recordDownload = { runnable: () -> Unit ->
+            Telemetry.languageserver.setup.use { telemetry ->
+                telemetry.id("q")
+                telemetry.languageServerSetupStage(LanguageServerSetupStage.GetServer)
+                telemetry.metadata("credentialStartUrl", getStartUrl(project))
+                telemetry.success(true)
+
+                try {
+                    runnable()
+                } catch (t: Throwable) {
+                    telemetry.success(false)
+                    telemetry.recordException(t)
+                }
+            }
+        }
+
         try {
             if (!filePath.exists()) {
                 logger.info { "Downloading file: ${filePath.fileName}" }
-                saveFileFromUrl(url, filePath, ProgressManager.getInstance().progressIndicator)
+                recordDownload { saveFileFromUrl(url, filePath, ProgressManager.getInstance().progressIndicator) }
             }
             if (!validateFileHash(filePath, expectedHash)) {
                 logger.warn { "Hash mismatch for ${filePath.fileName}, re-downloading" }
                 filePath.deleteIfExists()
-                saveFileFromUrl(url, filePath)
-                if (!validateFileHash(filePath, expectedHash)) {
-                    throw LspException("Hash mismatch after re-download for ${filePath.fileName}", LspException.ErrorCode.HASH_MISMATCH)
+                recordDownload { saveFileFromUrl(url, filePath) }
+
+                Telemetry.languageserver.setup.use {
+                    it.id("q")
+                    it.languageServerSetupStage(LanguageServerSetupStage.Validate)
+                    it.metadata("credentialStartUrl", getStartUrl(project))
+                    it.success(true)
+
+                    if (!validateFileHash(filePath, expectedHash)) {
+                        it.success(false)
+
+                        val exception = LspException("Hash mismatch after re-download for ${filePath.fileName}", LspException.ErrorCode.HASH_MISMATCH)
+                        it.recordException(exception)
+                        throw exception
+                    }
                 }
             }
         } catch (e: Exception) {