aws · rli · May 20, 2025 · May 19, 2025 · May 19, 2025 · May 19, 2025
@@ -11,7 +11,6 @@ import com.intellij.openapi.project.DumbAwareAction
 import com.intellij.util.messages.Topic
 import software.aws.toolkits.jetbrains.services.amazonq.toolwindow.AmazonQToolWindow
 import software.aws.toolkits.resources.AmazonQBundle
-import software.aws.toolkits.resources.message
 import java.util.EventListener
 
 class QRefreshPanelAction : DumbAwareAction(AmazonQBundle.message("amazonq.refresh.panel"), null, AllIcons.Actions.Refresh) {

@@ -24,7 +24,6 @@ class AmazonQToolWindow private constructor(
 
     val component
         get() = chatPanel.component
-
     fun disposeAndRecreate() {
         Disposer.dispose(chatPanel)
         chatPanel = AmazonQPanel(project, scope)

@@ -66,7 +66,7 @@
                     ToolkitConnectionManager.getInstance(project).activeConnectionForFeature(QConnection.getInstance())?.let { qConn ->
                         openMeetQPage(project)
                     }
-                    prepareChatContent(project, qPanel)
+                    preparePanelContent(project, qPanel)
                 }
             }
         )
@@ -75,7 +75,7 @@
             RefreshQChatPanelButtonPressedListener.TOPIC,
             object : RefreshQChatPanelButtonPressedListener {
                 override fun onRefresh() {
-                    prepareChatContent(project, qPanel)
+                    preparePanelContent(project, qPanel)
                 }
             }
         )
@@ -85,8 +85,7 @@
             object : BearerTokenProviderListener {
                 override fun onChange(providerId: String, newScopes: List<String>?) {
                     if (ToolkitConnectionManager.getInstance(project).connectionStateForFeature(QConnection.getInstance()) == BearerTokenAuthState.AUTHORIZED) {
-                        AmazonQToolWindow.getInstance(project).disposeAndRecreate()
-                        prepareChatContent(project, qPanel)
+                        preparePanelContent(project, qPanel)
                     }
                 }
             }
@@ -98,13 +97,12 @@
                 // note we name myProject intentionally ow it will shadow the "project" provided by the IDE
                 override fun onProfileSelected(myProject: Project, profile: QRegionProfile?) {
                     if (project.isDisposed) return
-                    AmazonQToolWindow.getInstance(project).disposeAndRecreate()
-                    prepareChatContent(project, qPanel)
+                    preparePanelContent(project, qPanel)
                 }
             }
         )
 
-        prepareChatContent(project, qPanel)
+        preparePanelContent(project, qPanel)
 
         val content = contentManager.factory.createContent(mainPanel, null, false).also {
             it.isCloseable = true
@@ -114,7 +112,7 @@
         contentManager.addContent(content)
     }
 
-    private fun prepareChatContent(
+    private fun preparePanelContent(
         project: Project,
         qPanel: Wrapper,
     ) {

@@ -11,7 +11,9 @@
 import kotlinx.coroutines.runBlocking
 import software.aws.toolkits.jetbrains.services.amazonq.lsp.flareChat.AsyncChatUiListener
 import software.aws.toolkits.jetbrains.services.amazonq.lsp.flareChat.FlareUiMessage
+import software.aws.toolkits.jetbrains.services.amazonq.lsp.model.aws.chat.GENERIC_COMMAND
 import software.aws.toolkits.jetbrains.services.amazonq.lsp.model.aws.chat.GenericCommandParams
+import software.aws.toolkits.jetbrains.services.amazonq.lsp.model.aws.chat.SEND_TO_PROMPT
 import software.aws.toolkits.jetbrains.services.amazonq.lsp.model.aws.chat.SendToPromptParams
 import software.aws.toolkits.jetbrains.services.amazonq.lsp.model.aws.chat.TriggerType
 import software.aws.toolkits.jetbrains.services.amazonq.messages.AmazonQMessage
@@ -36,23 +38,19 @@
                     val fileContext = contextExtractor.extractContextForTrigger(ExtractionTriggerType.ContextMenu)
                     val codeSelection = "\n```\n${fileContext.focusAreaContext?.codeSelection?.trimIndent()?.trim()}\n```\n"
                     var uiMessage: FlareUiMessage? = null
-                    if (command.verb != "sendToPrompt") {
+                    if (command.verb != SEND_TO_PROMPT) {
                         val params = GenericCommandParams(selection = codeSelection, triggerType = TriggerType.CONTEXT_MENU, genericCommand = command.name)
-                        uiMessage = FlareUiMessage(command = "genericCommand", params = params)
+                        uiMessage = FlareUiMessage(command = GENERIC_COMMAND, params = params)
                     } else {
                         val params = SendToPromptParams(selection = codeSelection, triggerType = TriggerType.CONTEXT_MENU)
-                        uiMessage = FlareUiMessage(command = "sendToPrompt", params = params)
+                        uiMessage = FlareUiMessage(command = SEND_TO_PROMPT, params = params)
                     }
                     AsyncChatUiListener.notifyPartialMessageUpdate(uiMessage)
                 }
             }
         }
     }
 
-    fun reportMessageClick(command: EditorContextCommand, issue: MutableMap<String, String>, project: Project) {
-        _messages.tryEmit(CodeScanIssueActionMessage(command, issue, project))
-    }
-
     // provide singleton access
     companion object {
         val instance = ActionRegistrar()

@@ -3,6 +3,55 @@
 
 package software.aws.toolkits.jetbrains.services.cwc.commands.codescan.actions
 
-import software.aws.toolkits.jetbrains.services.cwc.commands.EditorContextCommand
+import com.intellij.openapi.actionSystem.ActionManager
+import com.intellij.openapi.actionSystem.AnAction
+import com.intellij.openapi.actionSystem.AnActionEvent
+import com.intellij.openapi.actionSystem.DataKey
+import com.intellij.openapi.application.ApplicationManager
+import com.intellij.openapi.project.DumbAware
+import kotlinx.coroutines.runBlocking
+import software.aws.toolkits.jetbrains.services.amazonq.lsp.flareChat.AsyncChatUiListener
+import software.aws.toolkits.jetbrains.services.amazonq.lsp.flareChat.FlareUiMessage
+import software.aws.toolkits.jetbrains.services.amazonq.lsp.model.aws.chat.ChatPrompt
+import software.aws.toolkits.jetbrains.services.amazonq.lsp.model.aws.chat.SEND_TO_PROMPT
+import software.aws.toolkits.jetbrains.services.amazonq.lsp.model.aws.chat.SendToPromptParams
+import software.aws.toolkits.jetbrains.services.amazonq.lsp.model.aws.chat.TriggerType
 
-class ExplainCodeIssueAction : CodeScanQActions(EditorContextCommand.ExplainCodeScanIssue)
+class ExplainCodeIssueAction : AnAction(), DumbAware {
+    override fun actionPerformed(e: AnActionEvent) {
+        val issueDataKey = DataKey.create<MutableMap<String, String>>("amazonq.codescan.explainissue")
+        val issueContext = e.getData(issueDataKey) ?: return
+
+        ActionManager.getInstance().getAction("q.openchat").actionPerformed(e)
+
+        ApplicationManager.getApplication().executeOnPooledThread {
+            runBlocking {
+                // https://github.com/aws/aws-toolkit-vscode/blob/master/packages/amazonq/src/lsp/chat/commands.ts#L30
+                val codeSelection = "\n```\n${issueContext["code"]?.trimIndent()?.trim()}\n```\n"
+
+                val prompt = "Explain the issue \n\n " +
+                    "Issue:    \"${issueContext["title"]}\" \n" +
+                    "Code:    $codeSelection"
+
+                val modelPrompt = "Explain the issue ${issueContext["title"]} \n\n " +
+                    "Issue:    \"${issueContext["title"]}\" \n" +
+                    "Description:    ${issueContext["description"]} \n" +
+                    "Code:    $codeSelection and generate the code demonstrating the fix"
+
+                val params = SendToPromptParams(
+                    selection = codeSelection,
+                    triggerType = TriggerType.CONTEXT_MENU,
+                    prompt = ChatPrompt(
+                        prompt = prompt,
+                        escapedPrompt = modelPrompt,
+                        command = null
+                    ),
+                    autoSubmit = true
+                )
+
+                val uiMessage = FlareUiMessage(SEND_TO_PROMPT, params)
+                AsyncChatUiListener.notifyPartialMessageUpdate(uiMessage)
+            }
+        }
+    }
+}
@@ -32,7 +32,8 @@
         val fileName = getFileName(psiFile)
         val programmingLanguage = psiFile.programmingLanguage()
         val fileRelativePath = getRelativePathToContentRoot(editor)
-        return FileContextInfo(caretContext, fileName, programmingLanguage, fileRelativePath)
+        val fileUri = getFileUri(psiFile)
+        return FileContextInfo(caretContext, fileName, programmingLanguage, fileRelativePath, fileUri)
     }
 
     fun extractCaretContext(editor: Editor): CaretContext {
@@ -73,6 +74,11 @@
     private fun getFileName(psiFile: PsiFile): String =
         psiFile.name.substring(0, psiFile.name.length.coerceAtMost(CodeWhispererConstants.FILENAME_CHARS_LIMIT))
 
+    private fun getFileUri(psiFile: PsiFile): String? =
+        psiFile.virtualFile?.takeIf { it.isValid }?.let { vFile ->
+            vFile.url.substring(0, vFile.url.length.coerceAtMost(CodeWhispererConstants.FILENAME_CHARS_LIMIT))
+        }
+
     fun getRelativePathToContentRoot(editor: Editor): String? =
         editor.project?.let { project ->
             FileDocumentManager.getInstance().getFile(editor.document)?.let { vFile ->

@@ -47,6 +47,7 @@
     val filename: String,
     val programmingLanguage: CodeWhispererProgrammingLanguage,
     val fileRelativePath: String?,
+    val fileUri: String?,
 )
 
 data class RecommendationContext(

@@ -74,7 +74,8 @@ class CodeWhispererServiceTest : CodeWhispererTestBase() {
                 CaretContext(leftFileContext = "", rightFileContext = "public class Main {}", leftContextOnCurrentLine = ""),
                 "main.java",
                 CodeWhispererJava.INSTANCE,
-                "main.java"
+                "main.java",
+                file.virtualFile.url
             )
         )
     }

@@ -127,7 +127,7 @@ fun aFileContextInfo(language: CodeWhispererProgrammingLanguage? = null): FileCo
         CodeWhispererJava.INSTANCE
     ).random()
 
-    return FileContextInfo(caretContextInfo, fileName, programmingLanguage, fileRelativePath)
+    return FileContextInfo(caretContextInfo, fileName, programmingLanguage, fileRelativePath, null)
 }
 
 fun aTriggerType(): CodewhispererTriggerType =

@@ -8,7 +8,7 @@ import { ChatItem, MynahIcons } from '@aws/mynah-ui-chat'
 export const disclaimerAcknowledgeButtonId = 'amazonq-disclaimer-acknowledge-button-id'
 export const disclaimerCard: Partial<ChatItem> = {
     messageId: 'amazonq-disclaimer-card',
-    body: 'Amazon Q Developer uses generative AI. You may need to verify responses. See the [AWS Responsible AI Policy](https://aws.amazon.com/machine-learning/responsible-ai/policy/). Amazon Q Developer processes data across all US Regions. See [here](https://docs.aws.amazon.com/amazonq/latest/qdeveloper-ug/cross-region-inference.html) for more info. Amazon Q may retain chats to provide and maintain the service.',
+    body: 'Amazon Q Developer uses generative AI. You may need to verify responses. See the [AWS Responsible AI Policy](https://aws.amazon.com/machine-learning/responsible-ai/policy/). Amazon Q may retain chats to provide and maintain the service. For information on the AWS Regions where Amazon Q may perform inference, see [the documentation](https://docs.aws.amazon.com/amazonq/latest/qdeveloper-ug/cross-region-processing.html#cross-region-inference).',
     buttons: [
         {
             text: 'Acknowledge',

@@ -24,12 +24,16 @@
 import com.intellij.util.net.JdkProxyProvider
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Deferred
+import kotlinx.coroutines.Job
 import kotlinx.coroutines.async
 import kotlinx.coroutines.channels.BufferOverflow
+import kotlinx.coroutines.delay
 import kotlinx.coroutines.flow.MutableSharedFlow
 import kotlinx.coroutines.flow.asSharedFlow
 import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.future.asCompletableFuture
+import kotlinx.coroutines.isActive
+import kotlinx.coroutines.launch
 import kotlinx.coroutines.runBlocking
 import kotlinx.coroutines.sync.Mutex
 import kotlinx.coroutines.sync.withLock
@@ -52,6 +56,7 @@
 import org.eclipse.lsp4j.jsonrpc.messages.ResponseMessage
 import org.eclipse.lsp4j.launch.LSPLauncher
 import org.slf4j.event.Level
+import software.aws.toolkits.core.utils.debug
 import software.aws.toolkits.core.utils.getLogger
 import software.aws.toolkits.core.utils.info
 import software.aws.toolkits.core.utils.warn
@@ -128,6 +133,9 @@
 
     val encryptionManager
         get() = instance.getCompleted().encryptionManager
+    private val heartbeatJob: Job
+    private val restartTimestamps = ArrayDeque<Long>()
+    private val restartMutex = Mutex() // Separate mutex for restart tracking
 
     val rawEndpoint
         get() = instance.getCompleted().rawEndpoint
@@ -166,9 +174,50 @@
 
     init {
         instance = start()
+
+        // Initialize heartbeat job
+        heartbeatJob = cs.launch {
+            while (isActive) {
+                delay(5.seconds) // Check every 5 seconds
+                val shouldLoop = checkConnectionStatus()
+                if (!shouldLoop) {
+                    break
+                }
+            }
+        }
+    }
+
+    private suspend fun checkConnectionStatus(): Boolean {
+        try {
+            val currentInstance = mutex.withLock { instance }.await()
+
+            // Check if the launcher's Future (startListening) is done
+            // If it's done, that means the connection has been terminated
+            if (currentInstance.launcherFuture.isDone) {
+                LOG.debug { "LSP server connection terminated, checking restart limits" }
+                val canRestart = checkForRemainingRestartAttempts()
+                if (!canRestart) {
+                    return false
+                }
+                LOG.debug { "Restarting LSP server" }
+                restart()
+            } else {
+                LOG.debug { "LSP server is currently running" }
+            }
+        } catch (e: Exception) {
+            LOG.debug(e) { "Connection status check failed, checking restart limits" }
+            val canRestart = checkForRemainingRestartAttempts()
+            if (!canRestart) {
+                return false
+            }
+            LOG.debug { "Restarting LSP server" }
+            restart()
+        }
+        return true
     }
 
     override fun dispose() {
+        heartbeatJob.cancel()
     }
 
     suspend fun restart() = mutex.withLock {
@@ -195,6 +244,25 @@
         instance = start()
     }
 
+    private suspend fun checkForRemainingRestartAttempts(): Boolean = restartMutex.withLock {
+        val currentTime = System.currentTimeMillis()
+
+        while (restartTimestamps.isNotEmpty() &&
+            currentTime - restartTimestamps.first() > RESTART_WINDOW_MS
+        ) {
+            restartTimestamps.removeFirst()
+        }
+
+        if (restartTimestamps.size < MAX_RESTARTS) {
+            restartTimestamps.addLast(currentTime)
+            return true
+        }
+
+        LOG.info { "Rate limit reached for LSP server restarts. Stop attempting to restart." }
+
+        return false
+    }
+
     suspend fun<T> execute(runnable: suspend AmazonQLspService.(AmazonQLanguageServer) -> T): T {
         val lsp = withTimeout(10.seconds) {
             val holder = mutex.withLock { instance }.await()
@@ -212,6 +280,8 @@
 
     companion object {
         private val LOG = getLogger<AmazonQLspService>()
+        private const val MAX_RESTARTS = 5
+        private const val RESTART_WINDOW_MS = 3 * 60 * 1000
         fun getInstance(project: Project) = project.service<AmazonQLspService>()
 
         @Deprecated("Easy to accidentally freeze EDT")
@@ -241,7 +311,7 @@
         get() = launcher.remoteEndpoint
 
     @Suppress("ForbiddenVoid")
-    private val launcherFuture: Future<Void>
+    val launcherFuture: Future<Void>
     private val launcherHandler: KillableProcessHandler
     val initializeResult: Deferred<InitializeResult>
 

@@ -7,6 +7,7 @@
 import com.intellij.openapi.util.text.StringUtil
 import com.intellij.util.io.DigestUtil
 import com.intellij.util.system.CpuArch
+import org.apache.commons.io.FileUtils
 import software.aws.toolkits.core.utils.ZIP_PROPERTY_POSIX
 import software.aws.toolkits.core.utils.createParentDirectories
 import software.aws.toolkits.core.utils.exists
@@ -68,7 +69,8 @@
 fun moveFilesFromSourceToDestination(sourceDir: Path, targetDir: Path) {
     try {
         Files.createDirectories(targetDir.parent)
-        Files.move(sourceDir, targetDir, StandardCopyOption.REPLACE_EXISTING)
+        // NIO move does not work when copying across mount points (i.e. /tmp is on tmpfs)
+        FileUtils.moveDirectory(sourceDir.toFile(), targetDir.toFile())
     } catch (e: Exception) {
         throw IllegalStateException("Failed to move files from $sourceDir to $targetDir", e)
     }