merge: support chat on remote connections (#6008)

* feat(amazonq): Add support for Amazon Q chat on remote 242+ (#4825)

* fix(amazonq): Bug Fix for "Q: Send to Prompt" doesn't work in split panes on local or remote (#5463)

* fix(amazonq): use https as scheme for local webview resource resolver (#5489)

https://developer.mozilla.org/en-US/docs/Web/API/Clipboard
`navigator.clipboard` is only accessible from a "secure context", which JCEF does not think we are using,
because the URI authority is not localhost or https. Since we are hooking onto the CEF resource request handler,
it does not matter what we use for the scheme/authority as long as there is no conflict with real resources.

Previous implementation used a different load mechanism which somehow met the secure context criteria.

* fix(amazonq): fix agentic asset loading in remote mode (#5734)

local uris cannot be loaded if the host is deemed non-remote

* fix(amazonq): fix code issues tab not appearing in remote (#5737)

on remote, each client gets its own instance of the tool window.

logic needs to handle this case, otherwise it will only make changes against the 'main' IDE,
and will not be visible to remote clients

* fix(amazonq): use progress bar decorator while loading q chat on remote (#5749)

animated icons do not show up on remote

* fix: provide loading text when chat assets are slow to load (#5973)

on remote, it can take 10+ seconds for chat to be visible.

additionally, delete some unneeded assets to slightly reduce load time

* feat(amazonq): limit remote to amzn-internal compute (#5993)

Per internal discussion, feature deemed not ready for external users due to https://youtrack.jetbrains.com/issue/IJPL-203169

* fix: delete changelog for internal feature (#6009)

* feat: show message to resize on remote chat (#6007)

---------
Co-authored-by: Lokesh <[email protected]>

Author: rli

buildSrc/src/main/kotlin/software/aws/toolkits/gradle/intellij/IdeVersions.kt

@@ -22,7 +22,7 @@ object IdeVersions {
     private val commonPlugins = listOf(
         "Git4Idea",
         "org.jetbrains.plugins.terminal",
-        "org.jetbrains.plugins.yaml"
+        "org.jetbrains.plugins.yaml",
     )
 
     private val ideProfiles = listOf(
@@ -34,6 +34,7 @@ object IdeVersions {
                     "com.intellij.java",
                     "com.intellij.gradle",
                     "org.jetbrains.idea.maven",
+                    "com.jetbrains.codeWithMe",
                 ),
                 marketplacePlugins = listOf(
                     "org.toml.lang:242.20224.155",
@@ -71,6 +72,7 @@ object IdeVersions {
                     "com.intellij.java",
                     "com.intellij.gradle",
                     "org.jetbrains.idea.maven",
+                    "com.jetbrains.codeWithMe",
                 ),
                 marketplacePlugins = listOf(
                     "org.toml.lang:243.21565.122",
@@ -114,6 +116,7 @@ object IdeVersions {
                     "com.intellij.java",
                     "com.intellij.gradle",
                     "org.jetbrains.idea.maven",
+                    "com.jetbrains.codeWithMe",
                 ),
                 marketplacePlugins = listOf(
                     "org.toml.lang:251.26927.47",
@@ -160,6 +163,7 @@ object IdeVersions {
                     "com.intellij.java",
                     "com.intellij.gradle",
                     "org.jetbrains.idea.maven",
+                    "com.jetbrains.codeWithMe",
                     "com.intellij.properties"
                 ),
                 marketplacePlugins = listOf(

buildSrc/src/main/kotlin/toolkit-publish-root-conventions.gradle.kts

@@ -3,6 +3,7 @@
 
 import org.jetbrains.intellij.platform.gradle.IntelliJPlatformType
 import org.jetbrains.intellij.platform.gradle.tasks.PatchPluginXmlTask
+import org.jetbrains.intellij.platform.gradle.tasks.aware.SplitModeAware
 import software.aws.toolkits.gradle.intellij.IdeFlavor
 import software.aws.toolkits.gradle.intellij.toolkitIntelliJ
 
@@ -75,3 +76,8 @@ tasks.runIde {
     systemProperty("user.home", home)
     environment("HOME", home)
 }
+
+val runSplitIde by intellijPlatformTesting.runIde.registering {
+    splitMode = true
+    splitModeTarget = SplitModeAware.SplitModeTarget.BACKEND
+}

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

@@ -22,7 +22,6 @@ import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.flow.distinctUntilChanged
 import kotlinx.coroutines.flow.launchIn
 import kotlinx.coroutines.flow.onEach
-import org.cef.CefApp
 import software.aws.toolkits.core.utils.debug
 import software.aws.toolkits.core.utils.error
 import software.aws.toolkits.core.utils.getLogger
@@ -37,8 +36,8 @@ import software.aws.toolkits.jetbrains.core.credentials.sono.isSono
 import software.aws.toolkits.jetbrains.core.region.AwsRegionProvider
 import software.aws.toolkits.jetbrains.core.webview.BrowserMessage
 import software.aws.toolkits.jetbrains.core.webview.BrowserState
+import software.aws.toolkits.jetbrains.core.webview.LocalAssetJBCefRequestHandler
 import software.aws.toolkits.jetbrains.core.webview.LoginBrowser
-import software.aws.toolkits.jetbrains.core.webview.WebviewResourceHandlerFactory
 import software.aws.toolkits.jetbrains.isDeveloperMode
 import software.aws.toolkits.jetbrains.services.amazonq.profile.QProfileSwitchIntent
 import software.aws.toolkits.jetbrains.services.amazonq.profile.QRegionProfile
@@ -131,25 +130,14 @@ class QWebviewPanel private constructor(val project: Project, private val scope:
 class QWebviewBrowser(val project: Project, private val parentDisposable: Disposable) :
     LoginBrowser(
         project,
-        QWebviewBrowser.DOMAIN,
-        QWebviewBrowser.WEB_SCRIPT_URI
     ),
     Disposable {
     // TODO: confirm if we need such configuration or the default is fine
     override val jcefBrowser = createBrowser(parentDisposable)
     private val query = JBCefJSQuery.create(jcefBrowser)
+    private val assetHandler = LocalAssetJBCefRequestHandler(jcefBrowser)
 
     init {
-        CefApp.getInstance()
-            .registerSchemeHandlerFactory(
-                "http",
-                domain,
-                WebviewResourceHandlerFactory(
-                    domain = "http://$domain/",
-                    assetUri = "/webview/assets/"
-                ),
-            )
-
         loadWebView(query)
 
         query.addHandler(jcefHandler)
@@ -332,7 +320,12 @@ class QWebviewBrowser(val project: Project, private val parentDisposable: Dispos
     }
 
     override fun loadWebView(query: JBCefJSQuery) {
-        jcefBrowser.loadHTML(getWebviewHTML(webScriptUri, query))
+        val webScriptUri = assetHandler.createResource(
+            WEB_SCRIPT,
+            QWebviewBrowser::class.java.getResourceAsStream("/webview/assets/$WEB_SCRIPT")
+        )
+
+        jcefBrowser.loadURL(assetHandler.createResource("content.html", getWebviewHTML(webScriptUri, query)))
     }
 
     private fun handleListProfilesMessage() {
@@ -383,7 +376,6 @@ class QWebviewBrowser(val project: Project, private val parentDisposable: Dispos
 
     companion object {
         private val LOG = getLogger<QWebviewBrowser>()
-        private const val WEB_SCRIPT_URI = "http://webview/js/getStart.js"
-        private const val DOMAIN = "webview"
+        private const val WEB_SCRIPT = "js/getStart.js"
     }
 }

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

@@ -11,18 +11,20 @@ import icons.AwsIcons
 import software.aws.toolkits.jetbrains.services.amazonq.toolwindow.AMAZON_Q_WINDOW_ID
 import software.aws.toolkits.jetbrains.services.amazonq.toolwindow.AmazonQToolWindow
 import software.aws.toolkits.jetbrains.services.codewhisperer.util.CodeWhispererConstants.runScanKey
-import software.aws.toolkits.jetbrains.utils.isRunningOnRemoteBackend
 import software.aws.toolkits.resources.message
 import software.aws.toolkits.telemetry.UiTelemetry
 
 class QOpenPanelAction : AnAction(message("action.q.openchat.text"), null, AwsIcons.Logos.AWS_Q) {
     override fun actionPerformed(e: AnActionEvent) {
-        if (isRunningOnRemoteBackend()) return
         val project = e.getRequiredData(CommonDataKeys.PROJECT)
         UiTelemetry.click(project, "q_openChat")
         ToolWindowManager.getInstance(project).getToolWindow(AMAZON_Q_WINDOW_ID)?.activate(null, true)
         if (e.getData(runScanKey) == true) {
             AmazonQToolWindow.openScanTab(project)
         }
     }
+
+    override fun update(e: AnActionEvent) {
+        e.presentation.isEnabled = e.getData(CommonDataKeys.PROJECT) != null
+    }
 }

plugins/amazonq/chat/jetbrains-community/src/software/aws/toolkits/jetbrains/services/amazonq/gettingstarted/QGettingStartedContent.kt

@@ -18,6 +18,7 @@ import org.cef.browser.CefBrowser
 import org.cef.browser.CefFrame
 import org.cef.handler.CefLoadHandlerAdapter
 import software.aws.toolkits.jetbrains.core.coroutines.disposableCoroutineScope
+import software.aws.toolkits.jetbrains.core.webview.LocalAssetJBCefRequestHandler
 import software.aws.toolkits.jetbrains.services.amazonq.toolwindow.AmazonQToolWindow
 import software.aws.toolkits.jetbrains.services.amazonq.webview.theme.EditorThemeAdapter
 import software.aws.toolkits.resources.message
@@ -72,7 +73,7 @@ class QGettingStartedContent(val project: Project) : Disposable {
 
     private fun loadWebView() {
         // load the web app
-        jcefBrowser.loadHTML(getWebviewHTML())
+        jcefBrowser.loadURL(LocalAssetJBCefRequestHandler(jcefBrowser).createResource("content.html", getWebviewHTML()))
     }
 
     private fun getWebviewHTML(): String {

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

@@ -4,13 +4,13 @@
 package software.aws.toolkits.jetbrains.services.amazonq.toolwindow
 
 import com.fasterxml.jackson.module.kotlin.jacksonObjectMapper
-import com.intellij.idea.AppMode
 import com.intellij.openapi.Disposable
 import com.intellij.openapi.components.service
 import com.intellij.openapi.project.Project
 import com.intellij.openapi.util.Disposer
 import com.intellij.ui.components.JBLoadingPanel
 import com.intellij.ui.components.JBTextArea
+import com.intellij.ui.components.ProgressBarLoadingDecorator
 import com.intellij.ui.components.panels.Wrapper
 import com.intellij.ui.dsl.builder.Align
 import com.intellij.ui.dsl.builder.AlignX
@@ -45,6 +45,7 @@ import software.aws.toolkits.jetbrains.services.amazonqCodeTest.auth.isCodeTestA
 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.jetbrains.utils.isRunningOnRemoteBackend
 import software.aws.toolkits.resources.message
 import java.awt.datatransfer.DataFlavor
 import java.awt.dnd.DropTarget
@@ -92,8 +93,8 @@ class AmazonQPanel(val project: Project, private val scope: CoroutineScope) : Di
     init {
         if (!JBCefApp.isSupported()) {
             // Fallback to an alternative browser-less solution
-            if (AppMode.isRemoteDevHost()) {
-                webviewContainer.add(JBTextArea("Amazon Q chat is not supported in remote dev environment."))
+            if (isRunningOnRemoteBackend()) {
+                webviewContainer.add(JBTextArea("Amazon Q chat is not supported in this remote dev environment because it lacks JCEF webview support."))
             } else {
                 webviewContainer.add(JBTextArea("JCEF not supported"))
             }
@@ -102,21 +103,28 @@ class AmazonQPanel(val project: Project, private val scope: CoroutineScope) : Di
             webviewContainer.add(JBTextArea("${message("q.unavailable")}\n ${message("q.unavailable.node")}"))
             browser.complete(null)
         } else {
-            val loadingPanel = JBLoadingPanel(null, this)
+            val loadingPanel = if (isRunningOnRemoteBackend()) {
+                JBLoadingPanel(null) {
+                    ProgressBarLoadingDecorator(it, this, -1)
+                }
+            } else {
+                JBLoadingPanel(null, this)
+            }
+
             val wrapper = Wrapper()
             loadingPanel.startLoading()
 
             webviewContainer.add(wrapper)
             wrapper.setContent(loadingPanel)
 
             scope.launch {
-                val webUri = service<ArtifactManager>().fetchArtifact(project).resolve("amazonq-ui.js").toUri()
+                val mynahAsset = service<ArtifactManager>().fetchArtifact(project).resolve("amazonq-ui.js")
                 // wait for server to be running
                 AmazonQLspService.getInstance(project).instanceFlow.first()
 
                 withContext(EDT) {
                     browser.complete(
-                        Browser(this@AmazonQPanel, webUri, project).also { browserInstance ->
+                        Browser(this@AmazonQPanel, mynahAsset, project).also { browserInstance ->
                             wrapper.setContent(browserInstance.component())
 
                             // Register direct callback instead of using message bus

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

@@ -20,6 +20,8 @@ import software.aws.toolkits.jetbrains.core.credentials.ToolkitConnectionManager
 import software.aws.toolkits.jetbrains.core.credentials.pinning.QConnection
 import software.aws.toolkits.jetbrains.core.credentials.sso.bearer.BearerTokenAuthState
 import software.aws.toolkits.jetbrains.core.credentials.sso.bearer.BearerTokenProviderListener
+import software.aws.toolkits.jetbrains.core.notifications.BannerContent
+import software.aws.toolkits.jetbrains.core.notifications.NotificationDismissalState
 import software.aws.toolkits.jetbrains.core.notifications.NotificationPanel
 import software.aws.toolkits.jetbrains.core.notifications.ProcessNotificationsBase
 import software.aws.toolkits.jetbrains.core.webview.BrowserState
@@ -32,6 +34,8 @@ import software.aws.toolkits.jetbrains.services.amazonq.profile.QRegionProfileSe
 import software.aws.toolkits.jetbrains.utils.isQConnected
 import software.aws.toolkits.jetbrains.utils.isQExpired
 import software.aws.toolkits.jetbrains.utils.isQWebviewsAvailable
+import software.aws.toolkits.jetbrains.utils.isRunningOnRemoteBackend
+import software.aws.toolkits.resources.AmazonQBundle
 import software.aws.toolkits.resources.message
 import software.aws.toolkits.telemetry.FeatureId
 import java.awt.event.ComponentAdapter
@@ -42,7 +46,18 @@ class AmazonQToolWindowFactory : ToolWindowFactory, DumbAware {
     override fun createToolWindowContent(project: Project, toolWindow: ToolWindow) {
         val mainPanel = BorderLayoutPanel()
         val qPanel = Wrapper()
-        val notificationPanel = NotificationPanel()
+        val notificationPanel = NotificationPanel().apply {
+            if (isRunningOnRemoteBackend() && !NotificationDismissalState.getInstance().isDismissed(REMOTE_RESIZE_NOTIFICATION_ID)) {
+                updateNotificationPanel(
+                    BannerContent(
+                        REMOTE_RESIZE_NOTIFICATION_ID,
+                        AmazonQBundle.message("amazonq.resize.panel"),
+                        // message is not used for banner
+                        "",
+                    )
+                )
+            }
+        }
 
         mainPanel.addToTop(notificationPanel)
         mainPanel.add(qPanel)
@@ -133,8 +148,12 @@ class AmazonQToolWindowFactory : ToolWindowFactory, DumbAware {
         }
     }
 
+    /**
+     * Only applies to local
+     * On remote, since we are using PROJECTOR_INSTANCING, this will never run
+     */
     override fun init(toolWindow: ToolWindow) {
-        toolWindow.stripeTitle = message("q.window.title")
+        toolWindow.stripeTitle = message("toolwindow.stripe.amazon.q.window")
         toolWindow.component.addComponentListener(
             object : ComponentAdapter() {
                 override fun componentResized(e: ComponentEvent) {
@@ -143,6 +162,8 @@ class AmazonQToolWindowFactory : ToolWindowFactory, DumbAware {
                     LOG.debug {
                         "Amazon Q Tool window stretched to a width less than the minimum allowed width, resizing to the minimum allowed width"
                     }
+
+                    // can't implement equivalent on remote as stretchWidth impl is noop
                     (toolWindow as ToolWindowEx).stretchWidth(MINIMUM_TOOLWINDOW_WIDTH - newWidth)
                 }
             }
@@ -155,5 +176,6 @@ class AmazonQToolWindowFactory : ToolWindowFactory, DumbAware {
         private val LOG = getLogger<AmazonQToolWindowFactory>()
         const val WINDOW_ID = AMAZON_Q_WINDOW_ID
         private const val MINIMUM_TOOLWINDOW_WIDTH = 325
+        private const val REMOTE_RESIZE_NOTIFICATION_ID = "resize.amazon.q.toolwindow.if.remote"
     }
 }