From a26437735b08d60fa21e7db9269ad6f2c5a3c1bb Mon Sep 17 00:00:00 2001
From: "Justin M. Keyes" <jmkeyes@amazon.com>
Date: Wed, 16 Apr 2025 08:38:17 -0700
Subject: [PATCH 01/13] fix(lsp): verify that nodejs runs before starting LSP
 client #7043

## Problem
When lsp fetch/install/start fails it does not mention the download
path, which could help with troubleshooting. #6972

    [info] using amazonqWorkspaceLsp service configuration: default
[info] lsp: Failed to download latest "AmazonQ-Workspace" manifest.
Falling back to local manifest.
    [info] lsp: Finished setting up LSP server
    [info] [Error] Starting client failed
    [info] Error: write EPIPE

## Solution
- Validate that `node` can actually run, before passing it to
`LspClient`.
- Add more logging.

Also captured by telemetry:

```
2025-04-16 08:24:51.738 [debug] telemetry: languageServer_setup {
  Metadata: {
    missingFields: 'id',
    metricId: '8da91a4b-ee00-4115-9b9e-796b5357402c',
    traceId: '8569c16e-d319-486e-a6f3-d4ee91698468',
    languageServerSetupStage: 'all',
    duration: '1417',
    result: 'Failed',
    reason: 'Error',
    reasonDesc: 'amazonqLsp: failed to run basic "node -e" test (exitcode=-2): [/Users/x/x/x/aws/x/x/x/x/x -e console.log("ok " + process.version)]',
    awsAccount: 'not-set',
    awsRegion: 'us-east-1'
  },
  Value: 1,
  Unit: 'Milliseconds',
  Passive: true
}
```
---
 .../amazonq/src/lsp/chat/webviewProvider.ts   |  2 +-
 .../test/unit/amazonq/lsp/lspClient.test.ts   | 20 +++-
 packages/core/src/amazonq/index.ts            |  1 +
 packages/core/src/amazonq/lsp/lspClient.ts    | 92 +++++++++++++++----
 .../webview/generators/webViewContent.ts      | 11 +--
 packages/core/src/shared/logger/logger.ts     |  1 +
 .../core/src/shared/lsp/baseLspInstaller.ts   | 11 ++-
 packages/core/src/shared/lsp/lspResolver.ts   | 29 +++++-
 packages/core/src/shared/lsp/types.ts         | 31 +++++++
 9 files changed, 166 insertions(+), 32 deletions(-)

diff --git a/packages/amazonq/src/lsp/chat/webviewProvider.ts b/packages/amazonq/src/lsp/chat/webviewProvider.ts
index 426af63739d..e1eb3215395 100644
--- a/packages/amazonq/src/lsp/chat/webviewProvider.ts
+++ b/packages/amazonq/src/lsp/chat/webviewProvider.ts
@@ -50,7 +50,7 @@ export class AmazonQChatViewProvider implements WebviewViewProvider {
     ) {
         this.webview = webviewView.webview
 
-        const lspDir = Uri.parse(LanguageServerResolver.defaultDir)
+        const lspDir = Uri.parse(LanguageServerResolver.defaultDir())
         webviewView.webview.options = {
             enableScripts: true,
             enableCommandUris: true,
diff --git a/packages/amazonq/test/unit/amazonq/lsp/lspClient.test.ts b/packages/amazonq/test/unit/amazonq/lsp/lspClient.test.ts
index 0ffb6adc907..369cda5402d 100644
--- a/packages/amazonq/test/unit/amazonq/lsp/lspClient.test.ts
+++ b/packages/amazonq/test/unit/amazonq/lsp/lspClient.test.ts
@@ -4,8 +4,8 @@
  */
 import * as sinon from 'sinon'
 import assert from 'assert'
-import { globals } from 'aws-core-vscode/shared'
-import { LspClient } from 'aws-core-vscode/amazonq'
+import { globals, getNodeExecutableName } from 'aws-core-vscode/shared'
+import { LspClient, lspClient as lspClientModule } from 'aws-core-vscode/amazonq'
 
 describe('Amazon Q LSP client', function () {
     let lspClient: LspClient
@@ -50,6 +50,22 @@ describe('Amazon Q LSP client', function () {
         assert.ok(!encryptedSample.includes('hello'))
     })
 
+    it('validates node executable + lsp bundle', async () => {
+        await assert.rejects(async () => {
+            await lspClientModule.activate(globals.context, {
+                // Mimic the `LspResolution<ResourcePaths>` type.
+                node: 'node.bogus.exe',
+                lsp: 'fake/lsp.js',
+            })
+        }, /.*failed to run basic .*node.*exitcode.*node\.bogus\.exe.*/)
+        await assert.rejects(async () => {
+            await lspClientModule.activate(globals.context, {
+                node: getNodeExecutableName(),
+                lsp: 'fake/lsp.js',
+            })
+        }, /.*failed to run .*exitcode.*node.*lsp\.js/)
+    })
+
     afterEach(() => {
         sinon.restore()
     })
diff --git a/packages/core/src/amazonq/index.ts b/packages/core/src/amazonq/index.ts
index 70223bf72d7..06af40f2c29 100644
--- a/packages/core/src/amazonq/index.ts
+++ b/packages/core/src/amazonq/index.ts
@@ -17,6 +17,7 @@ export {
 } from './onboardingPage/walkthrough'
 export { LspController } from './lsp/lspController'
 export { LspClient } from './lsp/lspClient'
+export * as lspClient from './lsp/lspClient'
 export { api } from './extApi'
 export { AmazonQChatViewProvider } from './webview/webView'
 export { init as cwChatAppInit } from '../codewhispererChat/app'
diff --git a/packages/core/src/amazonq/lsp/lspClient.ts b/packages/core/src/amazonq/lsp/lspClient.ts
index f2bfaca8d8a..61e19333f43 100644
--- a/packages/core/src/amazonq/lsp/lspClient.ts
+++ b/packages/core/src/amazonq/lsp/lspClient.ts
@@ -41,10 +41,13 @@ import globals from '../../shared/extensionGlobals'
 import { ResourcePaths } from '../../shared/lsp/types'
 import { createServerOptions } from '../../shared/lsp/utils/platform'
 import { waitUntil } from '../../shared/utilities/timeoutUtils'
+import { ToolkitError } from '../../shared/errors'
+import { ChildProcess } from '../../shared/utilities/processUtils'
 
 const localize = nls.loadMessageBundle()
 
 const key = crypto.randomBytes(32)
+const logger = getLogger('amazonqLsp.lspClient')
 
 /**
  * LspClient manages the API call between VS Code extension and LSP server
@@ -80,7 +83,7 @@ export class LspClient {
             const resp = await this.client?.sendRequest(BuildIndexRequestType, encryptedRequest)
             return resp
         } catch (e) {
-            getLogger().error(`LspClient: buildIndex error: ${e}`)
+            logger.error(`buildIndex error: ${e}`)
             return undefined
         }
     }
@@ -95,7 +98,7 @@ export class LspClient {
             const resp = await this.client?.sendRequest(QueryVectorIndexRequestType, encryptedRequest)
             return resp
         } catch (e) {
-            getLogger().error(`LspClient: queryVectorIndex error: ${e}`)
+            logger.error(`queryVectorIndex error: ${e}`)
             return []
         }
     }
@@ -111,7 +114,7 @@ export class LspClient {
             const resp: any = await this.client?.sendRequest(QueryInlineProjectContextRequestType, encrypted)
             return resp
         } catch (e) {
-            getLogger().error(`LspClient: queryInlineProjectContext error: ${e}`)
+            logger.error(`queryInlineProjectContext error: ${e}`)
             throw e
         }
     }
@@ -132,7 +135,7 @@ export class LspClient {
             const resp = await this.client?.sendRequest(UpdateIndexV2RequestType, encryptedRequest)
             return resp
         } catch (e) {
-            getLogger().error(`LspClient: updateIndex error: ${e}`)
+            logger.error(`updateIndex error: ${e}`)
             return undefined
         }
     }
@@ -144,7 +147,7 @@ export class LspClient {
             const resp: any = await this.client?.sendRequest(QueryRepomapIndexRequestType, await this.encrypt(request))
             return resp
         } catch (e) {
-            getLogger().error(`LspClient: QueryRepomapIndex error: ${e}`)
+            logger.error(`QueryRepomapIndex error: ${e}`)
             throw e
         }
     }
@@ -157,7 +160,7 @@ export class LspClient {
             )
             return resp
         } catch (e) {
-            getLogger().error(`LspClient: queryInlineProjectContext error: ${e}`)
+            logger.error(`queryInlineProjectContext error: ${e}`)
             throw e
         }
     }
@@ -174,7 +177,7 @@ export class LspClient {
             )
             return resp
         } catch (e) {
-            getLogger().error(`LspClient: getContextCommandItems error: ${e}`)
+            logger.error(`getContextCommandItems error: ${e}`)
             throw e
         }
     }
@@ -190,7 +193,7 @@ export class LspClient {
             )
             return resp || []
         } catch (e) {
-            getLogger().error(`LspClient: getContextCommandPrompt error: ${e}`)
+            logger.error(`getContextCommandPrompt error: ${e}`)
             throw e
         }
     }
@@ -204,7 +207,7 @@ export class LspClient {
             )
             return resp
         } catch (e) {
-            getLogger().error(`LspClient: getIndexSequenceNumber error: ${e}`)
+            logger.error(`getIndexSequenceNumber error: ${e}`)
             throw e
         }
     }
@@ -222,20 +225,65 @@ export class LspClient {
         )
     }
 }
+
 /**
- * Activates the language server, this will start LSP server running over IPC protocol.
- * It will create a output channel named Amazon Q Language Server.
- * This function assumes the LSP server has already been downloaded.
+ * Checks that we can actually run the `node` executable and execute code with it.
+ */
+async function validateNodeExe(nodePath: string, lsp: string, args: string[]) {
+    // Check that we can start `node` by itself.
+    const proc = new ChildProcess(nodePath, ['-e', 'console.log("ok " + process.version)'], { logging: 'no' })
+    const r = await proc.run()
+    const ok = r.exitCode === 0 && r.stdout.includes('ok')
+    if (!ok) {
+        const msg = `failed to run basic "node -e" test (exitcode=${r.exitCode}): ${proc}`
+        logger.error(msg)
+        throw new ToolkitError(`amazonqLsp: ${msg}`)
+    }
+
+    // Check that we can start `node …/lsp.js --stdio …`.
+    const lspProc = new ChildProcess(nodePath, [lsp, ...args], { logging: 'no' })
+    try {
+        // Start asynchronously (it never stops; we need to stop it below).
+        lspProc.run().catch((e) => logger.error('failed to run: %s', lspProc))
+
+        const ok2 =
+            !lspProc.stopped &&
+            (await waitUntil(
+                async () => {
+                    return lspProc.pid() !== undefined
+                },
+                {
+                    timeout: 5000,
+                    interval: 100,
+                    truthy: true,
+                }
+            ))
+        const selfExit = await waitUntil(async () => lspProc.stopped, {
+            timeout: 500,
+            interval: 100,
+            truthy: true,
+        })
+        if (!ok2 || selfExit) {
+            throw new ToolkitError(`amazonqLsp: failed to run (exitcode=${lspProc.exitCode()}): ${lspProc}`)
+        }
+    } finally {
+        lspProc.stop(true)
+    }
+}
+
+/**
+ * Activates the language server (assumes the LSP server has already been downloaded):
+ * 1. start LSP server running over IPC protocol.
+ * 2. create a output channel named Amazon Q Language Server.
  */
 export async function activate(extensionContext: ExtensionContext, resourcePaths: ResourcePaths) {
-    LspClient.instance
+    LspClient.instance // Tickle the singleton... :/
     const toDispose = extensionContext.subscriptions
 
     let rangeFormatting: Disposable | undefined
     // The debug options for the server
     // --inspect=6009: runs the server in Node's Inspector mode so VS Code can attach to the server for debugging
     const debugOptions = { execArgv: ['--nolazy', '--preserve-symlinks', '--stdio'] }
-
     const workerThreads = CodeWhispererSettings.instance.getIndexWorkerThreads()
     const gpu = CodeWhispererSettings.instance.isLocalIndexGPUEnabled()
 
@@ -259,6 +307,7 @@ export async function activate(extensionContext: ExtensionContext, resourcePaths
         debug: { module: serverModule, transport: TransportKind.ipc, options: debugOptions },
     }
 
+    // TODO(jmkeyes): this overwrites the above...?
     serverOptions = createServerOptions({
         encryptionKey: key,
         executable: resourcePaths.node,
@@ -268,6 +317,8 @@ export async function activate(extensionContext: ExtensionContext, resourcePaths
 
     const documentSelector = [{ scheme: 'file', language: '*' }]
 
+    await validateNodeExe(resourcePaths.node, resourcePaths.lsp, debugOptions.execArgv)
+
     // Options to control the language client
     const clientOptions: LanguageClientOptions = {
         // Register the server for json documents
@@ -359,10 +410,15 @@ export async function activate(extensionContext: ExtensionContext, resourcePaths
         })
     )
 
-    return LspClient.instance.client.onReady().then(() => {
-        const disposableFunc = { dispose: () => rangeFormatting?.dispose() as void }
-        toDispose.push(disposableFunc)
-    })
+    return LspClient.instance.client.onReady().then(
+        () => {
+            const disposableFunc = { dispose: () => rangeFormatting?.dispose() as void }
+            toDispose.push(disposableFunc)
+        },
+        (reason) => {
+            logger.error('client.onReady() failed: %O', reason)
+        }
+    )
 }
 
 export async function deactivate(): Promise<any> {
diff --git a/packages/core/src/amazonq/webview/generators/webViewContent.ts b/packages/core/src/amazonq/webview/generators/webViewContent.ts
index ef1d37a705e..ae6c30f4f6a 100644
--- a/packages/core/src/amazonq/webview/generators/webViewContent.ts
+++ b/packages/core/src/amazonq/webview/generators/webViewContent.ts
@@ -9,7 +9,6 @@ import { AuthUtil } from '../../../codewhisperer/util/authUtil'
 import { FeatureConfigProvider, FeatureContext } from '../../../shared/featureConfig'
 import globals from '../../../shared/extensionGlobals'
 import { isSageMaker } from '../../../shared/extensionUtilities'
-import { RegionProfile } from '../../../codewhisperer/models/model'
 import { AmazonQPromptSettings } from '../../../shared/settings'
 
 export class WebViewContentGenerator {
@@ -90,10 +89,10 @@ export class WebViewContentGenerator {
         // only show profile card when the two conditions
         //  1. profile count >= 2
         //  2. not default (fallback) which has empty arn
-        let regionProfile: RegionProfile | undefined = AuthUtil.instance.regionProfileManager.activeRegionProfile
-        if (AuthUtil.instance.regionProfileManager.profiles.length === 1) {
-            regionProfile = undefined
-        }
+        const regionProfile =
+            AuthUtil.instance.regionProfileManager.profiles.length === 1
+                ? undefined
+                : AuthUtil.instance.regionProfileManager.activeRegionProfile
 
         const regionProfileString: string = JSON.stringify(regionProfile)
         const authState = (await AuthUtil.instance.getChatAuthState()).amazonQ
@@ -104,7 +103,7 @@ export class WebViewContentGenerator {
         <script type="text/javascript">
             const init = () => {
                 createMynahUI(
-                    acquireVsCodeApi(), 
+                    acquireVsCodeApi(),
                     ${authState === 'connected'},
                     ${featureConfigsString},
                     ${welcomeLoadCount},
diff --git a/packages/core/src/shared/logger/logger.ts b/packages/core/src/shared/logger/logger.ts
index 3338602685a..9b4bead6a37 100644
--- a/packages/core/src/shared/logger/logger.ts
+++ b/packages/core/src/shared/logger/logger.ts
@@ -14,6 +14,7 @@ export type LogTopic =
     | 'lsp'
     | 'amazonqWorkspaceLsp'
     | 'amazonqLsp'
+    | 'amazonqLsp.lspClient'
     | 'chat'
     | 'stepfunctions'
     | 'unknown'
diff --git a/packages/core/src/shared/lsp/baseLspInstaller.ts b/packages/core/src/shared/lsp/baseLspInstaller.ts
index 12b5cdb9341..593b11a30c9 100644
--- a/packages/core/src/shared/lsp/baseLspInstaller.ts
+++ b/packages/core/src/shared/lsp/baseLspInstaller.ts
@@ -54,10 +54,19 @@ export abstract class BaseLspInstaller<T extends ResourcePaths = ResourcePaths,
         const deletedVersions = await cleanLspDownloads(manifest.versions, nodePath.dirname(assetDirectory))
         this.logger.debug(`cleaning old LSP versions deleted ${deletedVersions.length} versions`)
 
-        return {
+        const r = {
             ...installationResult,
+            // Example:
+            // ```
+            // resourcePaths = {
+            //     lsp = '<cachedir>/aws/toolkits/language-servers/AmazonQ/3.3.0/servers/aws-lsp-codewhisperer.js'
+            //     node = '<cachedir>/aws/toolkits/language-servers/AmazonQ/3.3.0/servers/node'
+            //     ui = '<cachedir>/aws/toolkits/language-servers/AmazonQ/3.3.0/clients/amazonq-ui.js'
+            // }
+            // ```
             resourcePaths: this.resourcePaths(assetDirectory),
         }
+        return r
     }
 
     protected abstract postInstall(assetDirectory: string): Promise<void>
diff --git a/packages/core/src/shared/lsp/lspResolver.ts b/packages/core/src/shared/lsp/lspResolver.ts
index 5d19e35f836..09c2970e702 100644
--- a/packages/core/src/shared/lsp/lspResolver.ts
+++ b/packages/core/src/shared/lsp/lspResolver.ts
@@ -47,25 +47,40 @@ export class LanguageServerResolver {
 
             const serverResolvers: StageResolver<LspResult>[] = [
                 {
+                    // 1: Use the current local ("cached") LSP server bundle, if any.
                     resolve: async () => await this.getLocalServer(cacheDirectory, latestVersion, targetContents),
                     telemetryMetadata: { id: this.lsName, languageServerLocation: 'cache' },
                 },
                 {
+                    // 2: Download the latest LSP server bundle.
                     resolve: async () => await this.fetchRemoteServer(cacheDirectory, latestVersion, targetContents),
                     telemetryMetadata: { id: this.lsName, languageServerLocation: 'remote' },
                 },
                 {
+                    // 3: If the download fails, try an older, cached version.
                     resolve: async () => await this.getFallbackServer(latestVersion),
                     telemetryMetadata: { id: this.lsName, languageServerLocation: 'fallback' },
                 },
             ]
 
-            return await tryStageResolvers('getServer', serverResolvers, getServerVersion)
+            /**
+             * Example:
+             * ```
+             * LspResult {
+             *   assetDirectory = "<cachedir>/aws/toolkits/language-servers/AmazonQ/3.3.0"
+             *   location = 'cache'
+             *   version = '3.3.0'
+             * }
+             * ```
+             */
+            const resolved = await tryStageResolvers('getServer', serverResolvers, getServerVersion)
+            return resolved
         } finally {
             logger.info(`Finished setting up LSP server`)
         }
     }
 
+    /** Finds an older, cached version of the LSP server bundle. */
     private async getFallbackServer(latestVersion: LspVersion): Promise<LspResult> {
         const fallbackDirectory = await this.getFallbackDir(latestVersion.serverVersion)
         if (!fallbackDirectory) {
@@ -96,6 +111,7 @@ export class LanguageServerResolver {
         return timeout
     }
 
+    /** Downloads the latest LSP server bundle. */
     private async fetchRemoteServer(
         cacheDirectory: string,
         latestVersion: LspVersion,
@@ -117,6 +133,7 @@ export class LanguageServerResolver {
         }
     }
 
+    /** Gets the current local ("cached") LSP server bundle. */
     private async getLocalServer(
         cacheDirectory: string,
         latestVersion: LspVersion,
@@ -417,13 +434,17 @@ export class LanguageServerResolver {
         return version.targets.find((x) => x.arch === arch && x.platform === platform)
     }
 
-    // lazy calls to `getApplicationSupportFolder()` to avoid failure on windows.
-    public static get defaultDir() {
+    /**
+     * Gets platform-specific "cache" dir ("$LOCALAPPDATA/aws/…" or "~/.cache/aws/…").
+     *
+     * Lazy-calls `getCacheDir()` to avoid failure on Windows.
+     */
+    public static defaultDir() {
         return path.join(fs.getCacheDir(), `aws/toolkits/language-servers`)
     }
 
     defaultDownloadFolder() {
-        return path.join(LanguageServerResolver.defaultDir, `${this.lsName}`)
+        return path.join(LanguageServerResolver.defaultDir(), `${this.lsName}`)
     }
 
     private getDownloadDirectory(version: string) {
diff --git a/packages/core/src/shared/lsp/types.ts b/packages/core/src/shared/lsp/types.ts
index 21bd8ff4e77..3cc96dbe681 100644
--- a/packages/core/src/shared/lsp/types.ts
+++ b/packages/core/src/shared/lsp/types.ts
@@ -9,17 +9,48 @@ import { LanguageServerLocation, ManifestLocation } from '../telemetry/telemetry
 export const logger = getLogger('lsp')
 
 export interface LspResult {
+    /** Example: `"cache"` */
     location: LanguageServerLocation
+    /** Example: `"3.3.0"` */
     version: string
+    /** Example: `"<cachedir>/aws/toolkits/language-servers/AmazonQ/3.3.0"` */
     assetDirectory: string
 }
 
+/**
+ * Example:
+ * ```
+ * resourcePaths = {
+ *     lsp = '<cachedir>/aws/toolkits/language-servers/AmazonQ/3.3.0/servers/aws-lsp-codewhisperer.js'
+ *     node = '<cachedir>/aws/toolkits/language-servers/AmazonQ/3.3.0/servers/node'
+ *     ui = '<cachedir>/aws/toolkits/language-servers/AmazonQ/3.3.0/clients/amazonq-ui.js'
+ * }
+ * ```
+ */
 export interface ResourcePaths {
+    /**
+     * Path to `.js` bundle to be executed by `node`.
+     * Example: `"<cachedir>/aws/toolkits/language-servers/AmazonQ/3.3.0/servers/aws-lsp-codewhisperer.js"`
+     */
     lsp: string
+    /**
+     * Path to `node` (or `node.exe`) executable/binary.
+     * Example: `"<cachedir>/aws/toolkits/language-servers/AmazonQ/3.3.0/servers/node"`
+     */
     node: string
 }
 
 export interface LspResolution<T extends ResourcePaths> extends LspResult {
+    /**
+     * Example:
+     * ```
+     * resourcePaths = {
+     *     lsp = '<cachedir>/aws/toolkits/language-servers/AmazonQ/3.3.0/servers/aws-lsp-codewhisperer.js'
+     *     node = '<cachedir>/aws/toolkits/language-servers/AmazonQ/3.3.0/servers/node'
+     *     ui = '<cachedir>/aws/toolkits/language-servers/AmazonQ/3.3.0/clients/amazonq-ui.js'
+     * }
+     * ```
+     */
     resourcePaths: T
 }
 

From b127942e4495f3a93f7c6939d391a5d366f0eff0 Mon Sep 17 00:00:00 2001
From: Josh Pinkney <103940141+jpinkney-aws@users.noreply.github.com>
Date: Wed, 16 Apr 2025 14:44:23 -0400
Subject: [PATCH 02/13] fix(amazonq): quick action handler should add to tab
 storage (#7070)

## Problem
currently tabs get added to the tabs storage when the onTabAdd handler
gets called.

In hybrid chat, the onTabAdd handler will never get called, because it
first needs to be in the tabsStorage, which doesn't happen because the
onTabAdd handler hasn't been called

## Solution
in hybrid chat mode just add new tabs directly to the tabs storage


---

- Treat all work as PUBLIC. Private `feature/x` branches will not be
squash-merged at release time.
- Your code changes must meet the guidelines in
[CONTRIBUTING.md](https://github.com/aws/aws-toolkit-vscode/blob/master/CONTRIBUTING.md#guidelines).
- License: I confirm that my contribution is made under the terms of the
Apache 2.0 license.
---
 packages/core/src/amazonq/webview/ui/main.ts  |  9 ++-
 .../webview/ui/quickActions/handler.ts        | 63 +++++++++++--------
 2 files changed, 43 insertions(+), 29 deletions(-)

diff --git a/packages/core/src/amazonq/webview/ui/main.ts b/packages/core/src/amazonq/webview/ui/main.ts
index 7bd46801b03..81b6fdb1941 100644
--- a/packages/core/src/amazonq/webview/ui/main.ts
+++ b/packages/core/src/amazonq/webview/ui/main.ts
@@ -210,6 +210,7 @@ export class WebviewUIHandler {
                     isScanEnabled: this.isScanEnabled,
                     isTestEnabled: this.isTestEnabled,
                     isDocEnabled: this.isDocEnabled,
+                    hybridChat,
                     disabledCommands,
                 })
 
@@ -659,8 +660,11 @@ export class WebviewUIHandler {
             },
             onTabAdd: (tabID: string) => {
                 if (hybridChat) {
-                    // hybrid chat doesn't support the welcome page
-                    this.connector?.onTabAdd(tabID)
+                    /**
+                     * hybrid chat doesn't support the welcome page
+                     * tabs are already added by the quick action handler
+                     * so theres nothing we have to do here
+                     */
                     return
                 }
                 /**
@@ -1038,6 +1042,7 @@ export class WebviewUIHandler {
             isScanEnabled: this.isScanEnabled,
             isTestEnabled: this.isTestEnabled,
             isDocEnabled: this.isDocEnabled,
+            hybridChat,
         })
         this.textMessageHandler = new TextMessageHandler({
             mynahUIRef: this.mynahUIRef,
diff --git a/packages/core/src/amazonq/webview/ui/quickActions/handler.ts b/packages/core/src/amazonq/webview/ui/quickActions/handler.ts
index 85c96a1a39c..d9572e13728 100644
--- a/packages/core/src/amazonq/webview/ui/quickActions/handler.ts
+++ b/packages/core/src/amazonq/webview/ui/quickActions/handler.ts
@@ -19,6 +19,7 @@ export interface QuickActionsHandlerProps {
     isScanEnabled: boolean
     isTestEnabled: boolean
     isDocEnabled: boolean
+    hybridChat?: boolean
     disabledCommands?: string[]
 }
 
@@ -40,6 +41,7 @@ export class QuickActionHandler {
     private isScanEnabled: boolean
     private isTestEnabled: boolean
     private isDocEnabled: boolean
+    private isHybridChatEnabled: boolean
 
     constructor(props: QuickActionsHandlerProps) {
         this.mynahUIRef = props.mynahUIRef
@@ -58,6 +60,7 @@ export class QuickActionHandler {
         this.isGumbyEnabled = props.isGumbyEnabled
         this.isScanEnabled = props.isScanEnabled
         this.isTestEnabled = props.isTestEnabled
+        this.isHybridChatEnabled = props.hybridChat ?? false
     }
 
     /**
@@ -123,14 +126,8 @@ export class QuickActionHandler {
             return
         }
 
-        let affectedTabId: string | undefined = tabID
         // if there is no scan tab, open a new one
-        const currentTabType = this.tabsStorage.getTab(affectedTabId)?.type
-        if (currentTabType !== 'unknown' && currentTabType !== 'welcome') {
-            affectedTabId = this.mynahUI.updateStore('', {
-                loadingChat: true,
-            })
-        }
+        const affectedTabId: string | undefined = this.addTab(tabID)
 
         if (affectedTabId === undefined) {
             this.mynahUI.notify({
@@ -172,14 +169,8 @@ export class QuickActionHandler {
             return
         }
 
-        let affectedTabId: string | undefined = tabID
         // if there is no test tab, open a new one
-        const currentTabType = this.tabsStorage.getTab(affectedTabId)?.type
-        if (currentTabType !== 'unknown' && currentTabType !== 'welcome') {
-            affectedTabId = this.mynahUI.updateStore('', {
-                loadingChat: true,
-            })
-        }
+        const affectedTabId: string | undefined = this.addTab(tabID)
 
         if (affectedTabId === undefined) {
             this.mynahUI.notify({
@@ -212,12 +203,10 @@ export class QuickActionHandler {
             return
         }
 
-        let affectedTabId: string | undefined = props.tabID
         const realPromptText = props.chatPrompt?.escapedPrompt?.trim() ?? ''
-        const currentTabType = this.tabsStorage.getTab(affectedTabId)?.type
-        if (currentTabType !== 'unknown' && currentTabType !== 'welcome') {
-            affectedTabId = this.mynahUI.updateStore('', {})
-        }
+
+        const affectedTabId = this.addTab(props.tabID)
+
         if (affectedTabId === undefined) {
             this.mynahUI.notify({
                 content: uiComponentsTexts.noMoreTabsTooltip,
@@ -305,15 +294,8 @@ export class QuickActionHandler {
             return
         }
 
-        let affectedTabId: string | undefined = tabID
         // if there is no gumby tab, open a new one
-        const currentTabType = this.tabsStorage.getTab(affectedTabId)?.type
-        if (currentTabType !== 'unknown' && currentTabType !== 'welcome') {
-            affectedTabId = this.mynahUI.updateStore('', {
-                loadingChat: true,
-                cancelButtonWhenLoading: false,
-            })
-        }
+        const affectedTabId: string | undefined = this.addTab(tabID)
 
         if (affectedTabId === undefined) {
             this.mynahUI.notify({
@@ -343,6 +325,33 @@ export class QuickActionHandler {
         }
     }
 
+    private addTab(affectedTabId: string | undefined) {
+        if (!affectedTabId || !this.mynahUI) {
+            return
+        }
+
+        const currTab = this.mynahUI.getAllTabs()[affectedTabId]
+        const currTabWasUsed =
+            (currTab.store?.chatItems?.filter((item) => item.type === ChatItemType.PROMPT).length ?? 0) > 0
+        if (currTabWasUsed) {
+            affectedTabId = this.mynahUI.updateStore('', {
+                loadingChat: true,
+                cancelButtonWhenLoading: false,
+            })
+        }
+
+        if (affectedTabId && this.isHybridChatEnabled) {
+            this.tabsStorage.addTab({
+                id: affectedTabId,
+                type: 'unknown',
+                status: 'free',
+                isSelected: true,
+            })
+        }
+
+        return affectedTabId
+    }
+
     private handleClearCommand(tabID: string) {
         this.mynahUI?.updateStore(tabID, {
             chatItems: [],

From e5fa306fd730c351824a7d461eeb7abf9e760a72 Mon Sep 17 00:00:00 2001
From: "Justin M. Keyes" <jmkeyes@amazon.com>
Date: Wed, 16 Apr 2025 08:40:53 -0700
Subject: [PATCH 03/13] fix(lsp): Ambiguous or misleading log messages.

Problem:
Ambiguous or misleading log messages.

Solution:
Refine the logging logic.
---
 packages/core/src/amazonq/lsp/lspClient.ts    | 21 ++----
 packages/core/src/shared/lsp/lspResolver.ts   | 73 +++++++++----------
 .../core/src/shared/utilities/processUtils.ts |  5 +-
 3 files changed, 46 insertions(+), 53 deletions(-)

diff --git a/packages/core/src/amazonq/lsp/lspClient.ts b/packages/core/src/amazonq/lsp/lspClient.ts
index 61e19333f43..767af8dd5ee 100644
--- a/packages/core/src/amazonq/lsp/lspClient.ts
+++ b/packages/core/src/amazonq/lsp/lspClient.ts
@@ -15,7 +15,7 @@ import * as jose from 'jose'
 
 import { Disposable, ExtensionContext } from 'vscode'
 
-import { LanguageClient, LanguageClientOptions, ServerOptions, TransportKind } from 'vscode-languageclient'
+import { LanguageClient, LanguageClientOptions } from 'vscode-languageclient'
 import {
     BuildIndexRequestPayload,
     BuildIndexRequestType,
@@ -235,7 +235,7 @@ async function validateNodeExe(nodePath: string, lsp: string, args: string[]) {
     const r = await proc.run()
     const ok = r.exitCode === 0 && r.stdout.includes('ok')
     if (!ok) {
-        const msg = `failed to run basic "node -e" test (exitcode=${r.exitCode}): ${proc}`
+        const msg = `failed to run basic "node -e" test (exitcode=${r.exitCode}): ${proc.toString(false, true)}`
         logger.error(msg)
         throw new ToolkitError(`amazonqLsp: ${msg}`)
     }
@@ -244,7 +244,7 @@ async function validateNodeExe(nodePath: string, lsp: string, args: string[]) {
     const lspProc = new ChildProcess(nodePath, [lsp, ...args], { logging: 'no' })
     try {
         // Start asynchronously (it never stops; we need to stop it below).
-        lspProc.run().catch((e) => logger.error('failed to run: %s', lspProc))
+        lspProc.run().catch((e) => logger.error('failed to run: %s', lspProc.toString(false, true)))
 
         const ok2 =
             !lspProc.stopped &&
@@ -264,7 +264,9 @@ async function validateNodeExe(nodePath: string, lsp: string, args: string[]) {
             truthy: true,
         })
         if (!ok2 || selfExit) {
-            throw new ToolkitError(`amazonqLsp: failed to run (exitcode=${lspProc.exitCode()}): ${lspProc}`)
+            throw new ToolkitError(
+                `amazonqLsp: failed to run (exitcode=${lspProc.exitCode()}): ${lspProc.toString(false, true)}`
+            )
         }
     } finally {
         lspProc.stop(true)
@@ -300,18 +302,11 @@ export async function activate(extensionContext: ExtensionContext, resourcePaths
 
     const serverModule = resourcePaths.lsp
 
-    // If the extension is launch in debug mode the debug server options are use
-    // Otherwise the run options are used
-    let serverOptions: ServerOptions = {
-        run: { module: serverModule, transport: TransportKind.ipc },
-        debug: { module: serverModule, transport: TransportKind.ipc, options: debugOptions },
-    }
-
-    // TODO(jmkeyes): this overwrites the above...?
-    serverOptions = createServerOptions({
+    const serverOptions = createServerOptions({
         encryptionKey: key,
         executable: resourcePaths.node,
         serverModule,
+        // TODO(jmkeyes): we always use the debug options...?
         execArgv: debugOptions.execArgv,
     })
 
diff --git a/packages/core/src/shared/lsp/lspResolver.ts b/packages/core/src/shared/lsp/lspResolver.ts
index 09c2970e702..6950cb85b8a 100644
--- a/packages/core/src/shared/lsp/lspResolver.ts
+++ b/packages/core/src/shared/lsp/lspResolver.ts
@@ -40,44 +40,41 @@ export class LanguageServerResolver {
                 languageServerVersion: result.version,
             }
         }
-        try {
-            const latestVersion = this.latestCompatibleLspVersion()
-            const targetContents = this.getLSPTargetContents(latestVersion)
-            const cacheDirectory = this.getDownloadDirectory(latestVersion.serverVersion)
-
-            const serverResolvers: StageResolver<LspResult>[] = [
-                {
-                    // 1: Use the current local ("cached") LSP server bundle, if any.
-                    resolve: async () => await this.getLocalServer(cacheDirectory, latestVersion, targetContents),
-                    telemetryMetadata: { id: this.lsName, languageServerLocation: 'cache' },
-                },
-                {
-                    // 2: Download the latest LSP server bundle.
-                    resolve: async () => await this.fetchRemoteServer(cacheDirectory, latestVersion, targetContents),
-                    telemetryMetadata: { id: this.lsName, languageServerLocation: 'remote' },
-                },
-                {
-                    // 3: If the download fails, try an older, cached version.
-                    resolve: async () => await this.getFallbackServer(latestVersion),
-                    telemetryMetadata: { id: this.lsName, languageServerLocation: 'fallback' },
-                },
-            ]
-
-            /**
-             * Example:
-             * ```
-             * LspResult {
-             *   assetDirectory = "<cachedir>/aws/toolkits/language-servers/AmazonQ/3.3.0"
-             *   location = 'cache'
-             *   version = '3.3.0'
-             * }
-             * ```
-             */
-            const resolved = await tryStageResolvers('getServer', serverResolvers, getServerVersion)
-            return resolved
-        } finally {
-            logger.info(`Finished setting up LSP server`)
-        }
+        const latestVersion = this.latestCompatibleLspVersion()
+        const targetContents = this.getLSPTargetContents(latestVersion)
+        const cacheDirectory = this.getDownloadDirectory(latestVersion.serverVersion)
+
+        const serverResolvers: StageResolver<LspResult>[] = [
+            {
+                // 1: Use the current local ("cached") LSP server bundle, if any.
+                resolve: async () => await this.getLocalServer(cacheDirectory, latestVersion, targetContents),
+                telemetryMetadata: { id: this.lsName, languageServerLocation: 'cache' },
+            },
+            {
+                // 2: Download the latest LSP server bundle.
+                resolve: async () => await this.fetchRemoteServer(cacheDirectory, latestVersion, targetContents),
+                telemetryMetadata: { id: this.lsName, languageServerLocation: 'remote' },
+            },
+            {
+                // 3: If the download fails, try an older, cached version.
+                resolve: async () => await this.getFallbackServer(latestVersion),
+                telemetryMetadata: { id: this.lsName, languageServerLocation: 'fallback' },
+            },
+        ]
+
+        /**
+         * Example:
+         * ```
+         * LspResult {
+         *   assetDirectory = "<cachedir>/aws/toolkits/language-servers/AmazonQ/3.3.0"
+         *   location = 'cache'
+         *   version = '3.3.0'
+         * }
+         * ```
+         */
+        const resolved = await tryStageResolvers('getServer', serverResolvers, getServerVersion)
+        logger.info('Finished updating "%s" LSP server: %O', this.lsName, resolved.assetDirectory)
+        return resolved
     }
 
     /** Finds an older, cached version of the LSP server bundle. */
diff --git a/packages/core/src/shared/utilities/processUtils.ts b/packages/core/src/shared/utilities/processUtils.ts
index 31f2ec238f3..0204736f500 100644
--- a/packages/core/src/shared/utilities/processUtils.ts
+++ b/packages/core/src/shared/utilities/processUtils.ts
@@ -513,9 +513,10 @@ export class ChildProcess {
      * Gets a string representation of the process invocation.
      *
      * @param noparams Omit parameters in the result (to protect sensitive info).
+     * @param nostatus Omit "(not started)" note.
      */
-    public toString(noparams = false): string {
-        const pid = this.pid() > 0 ? `PID ${this.pid()}:` : '(not started)'
+    public toString(noparams = false, nostatus = false): string {
+        const pid = this.pid() > 0 ? `PID ${this.pid()}:` : nostatus ? '' : '(not started)'
         return `${pid} [${this.#command} ${noparams ? '...' : this.#args.join(' ')}]`
     }
 }

From 539ff4a90bce5e3c917fa42250e71e77260c9b24 Mon Sep 17 00:00:00 2001
From: "Justin M. Keyes" <jmkeyes@amazon.com>
Date: Wed, 16 Apr 2025 13:10:01 -0700
Subject: [PATCH 04/13] fix(lsp): manifest resolver always reports "Failed to
 download"
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Problem:
Manifest resolver always reports:

    Failed to download latest "…" manifest. Falling back to local manifest.

Solution:
In `fetchRemoteManifest()`, if the ETag indicates no new manifest is
needed, return the local manifest instead of throwing an error
---
 packages/amazonq/src/lsp/activation.ts        |  4 +--
 .../core/src/amazonq/lsp/lspController.ts     | 24 ++++++++---------
 .../core/src/shared/lsp/baseLspInstaller.ts   |  4 ++-
 packages/core/src/shared/lsp/lspResolver.ts   |  8 ++----
 .../core/src/shared/lsp/manifestResolver.ts   | 26 ++++++++++++++-----
 .../resourcefetcher/httpResourceFetcher.ts    |  4 +--
 6 files changed, 41 insertions(+), 29 deletions(-)

diff --git a/packages/amazonq/src/lsp/activation.ts b/packages/amazonq/src/lsp/activation.ts
index c4855c17970..84bae8a01a6 100644
--- a/packages/amazonq/src/lsp/activation.ts
+++ b/packages/amazonq/src/lsp/activation.ts
@@ -6,7 +6,7 @@
 import vscode from 'vscode'
 import { startLanguageServer } from './client'
 import { AmazonQLspInstaller } from './lspInstaller'
-import { lspSetupStage, ToolkitError } from 'aws-core-vscode/shared'
+import { lspSetupStage, ToolkitError, messages } from 'aws-core-vscode/shared'
 
 export async function activate(ctx: vscode.ExtensionContext): Promise<void> {
     try {
@@ -16,6 +16,6 @@ export async function activate(ctx: vscode.ExtensionContext): Promise<void> {
         })
     } catch (err) {
         const e = err as ToolkitError
-        void vscode.window.showInformationMessage(`Unable to launch amazonq language server: ${e.message}`)
+        void messages.showViewLogsMessage(`Failed to launch Amazon Q language server: ${e.message}`)
     }
 }
diff --git a/packages/core/src/amazonq/lsp/lspController.ts b/packages/core/src/amazonq/lsp/lspController.ts
index f20a415b305..3b7bd98a61d 100644
--- a/packages/core/src/amazonq/lsp/lspController.ts
+++ b/packages/core/src/amazonq/lsp/lspController.ts
@@ -98,11 +98,11 @@ export class LspController {
     }
 
     async buildIndex(buildIndexConfig: BuildIndexConfig) {
-        this.logger.info(`LspController: Starting to build index of project`)
+        this.logger.info(`Starting to build index of project`)
         const start = performance.now()
         const projPaths = (vscode.workspace.workspaceFolders ?? []).map((folder) => folder.uri.fsPath)
         if (projPaths.length === 0) {
-            this.logger.info(`LspController: Skipping building index. No projects found in workspace`)
+            this.logger.info(`Skipping building index. No projects found in workspace`)
             return
         }
         projPaths.sort()
@@ -119,12 +119,12 @@ export class LspController {
                 (accumulator, currentFile) => accumulator + currentFile.fileSizeBytes,
                 0
             )
-            this.logger.info(`LspController: Found ${files.length} files in current project ${projPaths}`)
+            this.logger.info(`Found ${files.length} files in current project ${projPaths}`)
             const config = buildIndexConfig.isVectorIndexEnabled ? 'all' : 'default'
             const r = files.map((f) => f.fileUri.fsPath)
             const resp = await LspClient.instance.buildIndex(r, projRoot, config)
             if (resp) {
-                this.logger.debug(`LspController: Finish building index of project`)
+                this.logger.debug(`Finish building index of project`)
                 const usage = await LspClient.instance.getLspServerUsage()
                 telemetry.amazonq_indexWorkspace.emit({
                     duration: performance.now() - start,
@@ -137,7 +137,7 @@ export class LspController {
                     credentialStartUrl: buildIndexConfig.startUrl,
                 })
             } else {
-                this.logger.error(`LspController: Failed to build index of project`)
+                this.logger.error(`Failed to build index of project`)
                 telemetry.amazonq_indexWorkspace.emit({
                     duration: performance.now() - start,
                     result: 'Failed',
@@ -149,7 +149,7 @@ export class LspController {
             }
         } catch (error) {
             // TODO: use telemetry.run()
-            this.logger.error(`LspController: Failed to build index of project`)
+            this.logger.error(`Failed to build index of project`)
             telemetry.amazonq_indexWorkspace.emit({
                 duration: performance.now() - start,
                 result: 'Failed',
@@ -166,7 +166,7 @@ export class LspController {
 
     async trySetupLsp(context: vscode.ExtensionContext, buildIndexConfig: BuildIndexConfig) {
         if (isCloud9() || isWeb() || isAmazonInternalOs()) {
-            this.logger.warn('LspController: Skipping LSP setup. LSP is not compatible with the current environment. ')
+            this.logger.warn('Skipping LSP setup. LSP is not compatible with the current environment. ')
             // do not do anything if in Cloud9 or Web mode or in AL2 (AL2 does not support node v18+)
             return
         }
@@ -181,7 +181,7 @@ export class LspController {
                         const usage = await LspClient.instance.getLspServerUsage()
                         if (usage) {
                             this.logger.info(
-                                `LspController: LSP server CPU ${usage.cpuUsage}%, LSP server Memory ${
+                                `LSP server CPU ${usage.cpuUsage}%, LSP server Memory ${
                                     usage.memoryUsage / (1024 * 1024)
                                 }MB  `
                             )
@@ -190,7 +190,7 @@ export class LspController {
                     30 * 60 * 1000
                 )
             } catch (e) {
-                this.logger.error(`LspController: LSP failed to activate ${e}`)
+                this.logger.error(`LSP failed to activate ${e}`)
             }
         })
     }
@@ -207,7 +207,7 @@ export class LspController {
             return
         }
         this._contextCommandSymbolsUpdated = true
-        getLogger().debug(`LspController: Start adding symbols to context picker menu`)
+        getLogger().debug(`Start adding symbols to context picker menu`)
         try {
             const indexSeqNum = await LspClient.instance.getIndexSequenceNumber()
             await LspClient.instance.updateIndex([], 'context_command_symbol_update')
@@ -223,7 +223,7 @@ export class LspController {
                 { interval: 1000, timeout: 60_000, truthy: true }
             )
         } catch (err) {
-            getLogger().error(`LspController: Failed to find symbols`)
+            this.logger.error(`Failed to find symbols`)
         }
     }
 
@@ -231,7 +231,7 @@ export class LspController {
         await lspSetupStage('all', async () => {
             const installResult = await new WorkspaceLspInstaller().resolve()
             await lspSetupStage('launch', async () => activateLsp(context, installResult.resourcePaths))
-            this.logger.info('LspController: LSP activated')
+            this.logger.info('LSP activated')
         })
     }
 }
diff --git a/packages/core/src/shared/lsp/baseLspInstaller.ts b/packages/core/src/shared/lsp/baseLspInstaller.ts
index 593b11a30c9..ee71b25a4b5 100644
--- a/packages/core/src/shared/lsp/baseLspInstaller.ts
+++ b/packages/core/src/shared/lsp/baseLspInstaller.ts
@@ -52,7 +52,9 @@ export abstract class BaseLspInstaller<T extends ResourcePaths = ResourcePaths,
         await this.postInstall(assetDirectory)
 
         const deletedVersions = await cleanLspDownloads(manifest.versions, nodePath.dirname(assetDirectory))
-        this.logger.debug(`cleaning old LSP versions deleted ${deletedVersions.length} versions`)
+        if (deletedVersions.length > 0) {
+            this.logger.debug(`cleaning old LSP versions: deleted ${deletedVersions.length} versions`)
+        }
 
         const r = {
             ...installationResult,
diff --git a/packages/core/src/shared/lsp/lspResolver.ts b/packages/core/src/shared/lsp/lspResolver.ts
index 6950cb85b8a..90892148a9f 100644
--- a/packages/core/src/shared/lsp/lspResolver.ts
+++ b/packages/core/src/shared/lsp/lspResolver.ts
@@ -73,7 +73,7 @@ export class LanguageServerResolver {
          * ```
          */
         const resolved = await tryStageResolvers('getServer', serverResolvers, getServerVersion)
-        logger.info('Finished updating "%s" LSP server: %O', this.lsName, resolved.assetDirectory)
+        logger.info('Finished preparing "%s" LSP server: %O', this.lsName, resolved.assetDirectory)
         return resolved
     }
 
@@ -144,11 +144,7 @@ export class LanguageServerResolver {
             }
         } else {
             // Delete the cached directory since it's invalid
-            if (await fs.existsDir(cacheDirectory)) {
-                await fs.delete(cacheDirectory, {
-                    recursive: true,
-                })
-            }
+            await fs.delete(cacheDirectory, { force: true, recursive: true })
             throw new ToolkitError('Failed to retrieve server from cache', { code: 'InvalidCache' })
         }
     }
diff --git a/packages/core/src/shared/lsp/manifestResolver.ts b/packages/core/src/shared/lsp/manifestResolver.ts
index 289fc63268d..60cc466a835 100644
--- a/packages/core/src/shared/lsp/manifestResolver.ts
+++ b/packages/core/src/shared/lsp/manifestResolver.ts
@@ -64,11 +64,20 @@ export class ManifestResolver {
         }).getNewETagContent(this.getEtag())
 
         if (!resp.content) {
-            throw new ToolkitError(
-                `New content was not downloaded; fallback to the locally stored "${this.lsName}" manifest`
-            )
+            const msg = `"${this.lsName}" manifest unchanged, skipping download: ${this.manifestURL}`
+            logger.debug(msg)
+
+            const localManifest = await this.getLocalManifest(true).catch(() => undefined)
+            if (localManifest) {
+                localManifest.location = 'remote'
+                return localManifest
+            } else {
+                // Will emit a `languageServer_setup` result=failed metric...
+                throw new ToolkitError(msg)
+            }
         }
 
+        logger.debug(`fetched "${this.lsName}" manifest: ${this.manifestURL}`)
         const manifest = this.parseManifest(resp.content)
         await this.saveManifest(resp.eTag, resp.content)
         await this.checkDeprecation(manifest)
@@ -76,13 +85,17 @@ export class ManifestResolver {
         return manifest
     }
 
-    private async getLocalManifest(): Promise<Manifest> {
-        logger.info(`Failed to download latest "${this.lsName}" manifest. Falling back to local manifest.`)
+    private async getLocalManifest(silent: boolean = false): Promise<Manifest> {
+        if (!silent) {
+            logger.info(`trying local "${this.lsName}" manifest...`)
+        }
         const storage = this.getStorage()
         const manifestData = storage[this.lsName]
 
         if (!manifestData?.content) {
-            throw new ToolkitError(`Failed to download "${this.lsName}" manifest and no local manifest found.`)
+            const msg = `local "${this.lsName}" manifest not found`
+            logger.warn(msg)
+            throw new ToolkitError(msg)
         }
 
         const manifest = this.parseManifest(manifestData.content)
@@ -145,6 +158,7 @@ export class ManifestResolver {
             ...storage,
             [this.lsName]: {
                 etag,
+                // XXX: this stores the entire manifest. vscode warns about our globalStorage size...
                 content,
             },
         })
diff --git a/packages/core/src/shared/resourcefetcher/httpResourceFetcher.ts b/packages/core/src/shared/resourcefetcher/httpResourceFetcher.ts
index 18cc696770f..b79b673c74d 100644
--- a/packages/core/src/shared/resourcefetcher/httpResourceFetcher.ts
+++ b/packages/core/src/shared/resourcefetcher/httpResourceFetcher.ts
@@ -68,9 +68,9 @@ export class HttpResourceFetcher implements ResourceFetcher<Response> {
         if (response.status === 304) {
             // Explanation: https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/If-None-Match
             contents = undefined
-            this.logger.verbose(`E-Tag, ${eTagResponse}, matched. No content downloaded from: ${this.url}`)
+            this.logger.verbose(`E-Tag matched (${eTagResponse}). Download skipped: ${this.url}`)
         } else {
-            this.logger.verbose(`No E-Tag match. Downloaded content from: ${this.logText()}`)
+            this.logger.verbose(`E-Tag not matched. Downloaded: ${this.logText()}`)
         }
 
         return { content: contents, eTag: eTagResponse }

From 05cf5558c00ff0d2780b368d95b176134f457d59 Mon Sep 17 00:00:00 2001
From: Josh Pinkney <jpink@amazon.com>
Date: Wed, 16 Apr 2025 19:15:11 -0400
Subject: [PATCH 05/13] fix(amazonq): use alpha manifest

---
 packages/amazonq/src/lsp/config.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/packages/amazonq/src/lsp/config.ts b/packages/amazonq/src/lsp/config.ts
index fb1b43b8d48..81cc9f59e6e 100644
--- a/packages/amazonq/src/lsp/config.ts
+++ b/packages/amazonq/src/lsp/config.ts
@@ -11,7 +11,7 @@ export interface ExtendedAmazonQLSPConfig extends LspConfig {
 }
 
 export const defaultAmazonQLspConfig: ExtendedAmazonQLSPConfig = {
-    manifestUrl: 'https://aws-toolkit-language-servers.amazonaws.com/codewhisperer/0/manifest.json',
+    manifestUrl: 'https://d3akiidp1wvqyg.cloudfront.net/codewhisperer/0/manifest.json',
     supportedVersions: '^3.1.1',
     id: 'AmazonQ', // used across IDEs for identifying global storage/local disk locations. Do not change.
     suppressPromptPrefix: 'amazonQ',

From 2befa25c6c1e55ca3af908224e6ca399a0df8782 Mon Sep 17 00:00:00 2001
From: "Justin M. Keyes" <jmkeyes@amazon.com>
Date: Wed, 16 Apr 2025 16:32:44 -0700
Subject: [PATCH 06/13] fix(lsp): verify that nodejs runs (again) #7076

Problem:
The logic added in a26437735b08 wasn't added in the other "lsp startup"
module.

Solution:
Add it to the new module also.
---
 packages/amazonq/src/lsp/client.ts            | 29 +++++++---
 packages/core/src/amazonq/lsp/lspClient.ts    | 55 +------------------
 .../core/src/shared/lsp/utils/platform.ts     | 49 +++++++++++++++++
 3 files changed, 73 insertions(+), 60 deletions(-)

diff --git a/packages/amazonq/src/lsp/client.ts b/packages/amazonq/src/lsp/client.ts
index 3d26d1368f1..84079ad3b77 100644
--- a/packages/amazonq/src/lsp/client.ts
+++ b/packages/amazonq/src/lsp/client.ts
@@ -11,11 +11,21 @@ import { InlineCompletionManager } from '../app/inline/completion'
 import { AmazonQLspAuth, encryptionKey, notificationTypes } from './auth'
 import { AuthUtil } from 'aws-core-vscode/codewhisperer'
 import { ConnectionMetadata } from '@aws/language-server-runtimes/protocol'
-import { Settings, oidcClientName, createServerOptions, globals, Experiments, Commands } from 'aws-core-vscode/shared'
+import {
+    Settings,
+    oidcClientName,
+    createServerOptions,
+    globals,
+    Experiments,
+    Commands,
+    validateNodeExe,
+    getLogger,
+} from 'aws-core-vscode/shared'
 import { activate } from './chat/activation'
 import { AmazonQResourcePaths } from './lspInstaller'
 
 const localize = nls.loadMessageBundle()
+const logger = getLogger('amazonqLsp.lspClient')
 
 export async function startLanguageServer(
     extensionContext: vscode.ExtensionContext,
@@ -25,17 +35,18 @@ export async function startLanguageServer(
 
     const serverModule = resourcePaths.lsp
 
+    const argv = [
+        '--nolazy',
+        '--preserve-symlinks',
+        '--stdio',
+        '--pre-init-encryption',
+        '--set-credentials-encryption-key',
+    ]
     const serverOptions = createServerOptions({
         encryptionKey,
         executable: resourcePaths.node,
         serverModule,
-        execArgv: [
-            '--nolazy',
-            '--preserve-symlinks',
-            '--stdio',
-            '--pre-init-encryption',
-            '--set-credentials-encryption-key',
-        ],
+        execArgv: argv,
     })
 
     const documentSelector = [{ scheme: 'file', language: '*' }]
@@ -43,6 +54,8 @@ export async function startLanguageServer(
     const clientId = 'amazonq'
     const traceServerEnabled = Settings.instance.isSet(`${clientId}.trace.server`)
 
+    await validateNodeExe(resourcePaths.node, resourcePaths.lsp, argv, logger)
+
     // Options to control the language client
     const clientOptions: LanguageClientOptions = {
         // Register the server for json documents
diff --git a/packages/core/src/amazonq/lsp/lspClient.ts b/packages/core/src/amazonq/lsp/lspClient.ts
index 767af8dd5ee..b992fef2fe3 100644
--- a/packages/core/src/amazonq/lsp/lspClient.ts
+++ b/packages/core/src/amazonq/lsp/lspClient.ts
@@ -39,15 +39,13 @@ import { fs } from '../../shared/fs/fs'
 import { getLogger } from '../../shared/logger/logger'
 import globals from '../../shared/extensionGlobals'
 import { ResourcePaths } from '../../shared/lsp/types'
-import { createServerOptions } from '../../shared/lsp/utils/platform'
+import { createServerOptions, validateNodeExe } from '../../shared/lsp/utils/platform'
 import { waitUntil } from '../../shared/utilities/timeoutUtils'
-import { ToolkitError } from '../../shared/errors'
-import { ChildProcess } from '../../shared/utilities/processUtils'
 
 const localize = nls.loadMessageBundle()
 
 const key = crypto.randomBytes(32)
-const logger = getLogger('amazonqLsp.lspClient')
+const logger = getLogger('amazonqWorkspaceLsp')
 
 /**
  * LspClient manages the API call between VS Code extension and LSP server
@@ -226,53 +224,6 @@ export class LspClient {
     }
 }
 
-/**
- * Checks that we can actually run the `node` executable and execute code with it.
- */
-async function validateNodeExe(nodePath: string, lsp: string, args: string[]) {
-    // Check that we can start `node` by itself.
-    const proc = new ChildProcess(nodePath, ['-e', 'console.log("ok " + process.version)'], { logging: 'no' })
-    const r = await proc.run()
-    const ok = r.exitCode === 0 && r.stdout.includes('ok')
-    if (!ok) {
-        const msg = `failed to run basic "node -e" test (exitcode=${r.exitCode}): ${proc.toString(false, true)}`
-        logger.error(msg)
-        throw new ToolkitError(`amazonqLsp: ${msg}`)
-    }
-
-    // Check that we can start `node …/lsp.js --stdio …`.
-    const lspProc = new ChildProcess(nodePath, [lsp, ...args], { logging: 'no' })
-    try {
-        // Start asynchronously (it never stops; we need to stop it below).
-        lspProc.run().catch((e) => logger.error('failed to run: %s', lspProc.toString(false, true)))
-
-        const ok2 =
-            !lspProc.stopped &&
-            (await waitUntil(
-                async () => {
-                    return lspProc.pid() !== undefined
-                },
-                {
-                    timeout: 5000,
-                    interval: 100,
-                    truthy: true,
-                }
-            ))
-        const selfExit = await waitUntil(async () => lspProc.stopped, {
-            timeout: 500,
-            interval: 100,
-            truthy: true,
-        })
-        if (!ok2 || selfExit) {
-            throw new ToolkitError(
-                `amazonqLsp: failed to run (exitcode=${lspProc.exitCode()}): ${lspProc.toString(false, true)}`
-            )
-        }
-    } finally {
-        lspProc.stop(true)
-    }
-}
-
 /**
  * Activates the language server (assumes the LSP server has already been downloaded):
  * 1. start LSP server running over IPC protocol.
@@ -312,7 +263,7 @@ export async function activate(extensionContext: ExtensionContext, resourcePaths
 
     const documentSelector = [{ scheme: 'file', language: '*' }]
 
-    await validateNodeExe(resourcePaths.node, resourcePaths.lsp, debugOptions.execArgv)
+    await validateNodeExe(resourcePaths.node, resourcePaths.lsp, debugOptions.execArgv, logger)
 
     // Options to control the language client
     const clientOptions: LanguageClientOptions = {
diff --git a/packages/core/src/shared/lsp/utils/platform.ts b/packages/core/src/shared/lsp/utils/platform.ts
index 4d242c3833e..5d96ef496f4 100644
--- a/packages/core/src/shared/lsp/utils/platform.ts
+++ b/packages/core/src/shared/lsp/utils/platform.ts
@@ -4,7 +4,9 @@
  */
 
 import { ToolkitError } from '../../errors'
+import { Logger } from '../../logger/logger'
 import { ChildProcess } from '../../utilities/processUtils'
+import { waitUntil } from '../../utilities/timeoutUtils'
 import { isDebugInstance } from '../../vscode/env'
 
 export function getNodeExecutableName(): string {
@@ -24,6 +26,53 @@ function getEncryptionInit(key: Buffer): string {
     return JSON.stringify(request) + '\n'
 }
 
+/**
+ * Checks that we can actually run the `node` executable and execute code with it.
+ */
+export async function validateNodeExe(nodePath: string, lsp: string, args: string[], logger: Logger) {
+    // Check that we can start `node` by itself.
+    const proc = new ChildProcess(nodePath, ['-e', 'console.log("ok " + process.version)'], { logging: 'no' })
+    const r = await proc.run()
+    const ok = r.exitCode === 0 && r.stdout.includes('ok')
+    if (!ok) {
+        const msg = `failed to run basic "node -e" test (exitcode=${r.exitCode}): ${proc.toString(false, true)}`
+        logger.error(msg)
+        throw new ToolkitError(`amazonqLsp: ${msg}`)
+    }
+
+    // Check that we can start `node …/lsp.js --stdio …`.
+    const lspProc = new ChildProcess(nodePath, [lsp, ...args], { logging: 'no' })
+    try {
+        // Start asynchronously (it never stops; we need to stop it below).
+        lspProc.run().catch((e) => logger.error('failed to run: %s', lspProc.toString(false, true)))
+
+        const ok2 =
+            !lspProc.stopped &&
+            (await waitUntil(
+                async () => {
+                    return lspProc.pid() !== undefined
+                },
+                {
+                    timeout: 5000,
+                    interval: 100,
+                    truthy: true,
+                }
+            ))
+        const selfExit = await waitUntil(async () => lspProc.stopped, {
+            timeout: 500,
+            interval: 100,
+            truthy: true,
+        })
+        if (!ok2 || selfExit) {
+            throw new ToolkitError(
+                `amazonqLsp: failed to run (exitcode=${lspProc.exitCode()}): ${lspProc.toString(false, true)}`
+            )
+        }
+    } finally {
+        lspProc.stop(true)
+    }
+}
+
 export function createServerOptions({
     encryptionKey,
     executable,

From 772b35fabdf69b956a25b745855a029be106b6d9 Mon Sep 17 00:00:00 2001
From: Josh Pinkney <103940141+jpinkney-aws@users.noreply.github.com>
Date: Wed, 16 Apr 2025 19:41:27 -0400
Subject: [PATCH 07/13] fix(amazonq): improve lsp cleanup logic (#7075)

## Problem
When switching between different manifests, a newly downloaded version
might chronologically be older than all previously downloaded versions,
even though it's marked as the latest version in its own manifest. This
is why we are getting the EPIPE error when trying out the alpha
manifest. The cleanup deletes the language server right after it was
downloaded

## Solution
In such cases, we skip the cleanup process to preserve this version.
Otherwise we will get an EPIPE error. At this point the version that was
downloaded shouldn't be delisted, so we don't want to make sure its not
removed

---

- Treat all work as PUBLIC. Private `feature/x` branches will not be
squash-merged at release time.
- Your code changes must meet the guidelines in
[CONTRIBUTING.md](https://github.com/aws/aws-toolkit-vscode/blob/master/CONTRIBUTING.md#guidelines).
- License: I confirm that my contribution is made under the terms of the
Apache 2.0 license.
---
 packages/core/src/shared/lsp/baseLspInstaller.ts  |  6 +++++-
 packages/core/src/shared/lsp/utils/cleanup.ts     | 15 ++++++++++++++-
 .../src/test/shared/lsp/utils/cleanup.test.ts     |  8 ++++++--
 3 files changed, 25 insertions(+), 4 deletions(-)

diff --git a/packages/core/src/shared/lsp/baseLspInstaller.ts b/packages/core/src/shared/lsp/baseLspInstaller.ts
index 12b5cdb9341..6c37e0b13fd 100644
--- a/packages/core/src/shared/lsp/baseLspInstaller.ts
+++ b/packages/core/src/shared/lsp/baseLspInstaller.ts
@@ -51,7 +51,11 @@ export abstract class BaseLspInstaller<T extends ResourcePaths = ResourcePaths,
 
         await this.postInstall(assetDirectory)
 
-        const deletedVersions = await cleanLspDownloads(manifest.versions, nodePath.dirname(assetDirectory))
+        const deletedVersions = await cleanLspDownloads(
+            installationResult.version,
+            manifest.versions,
+            nodePath.dirname(assetDirectory)
+        )
         this.logger.debug(`cleaning old LSP versions deleted ${deletedVersions.length} versions`)
 
         return {
diff --git a/packages/core/src/shared/lsp/utils/cleanup.ts b/packages/core/src/shared/lsp/utils/cleanup.ts
index 83b58e2bb8f..3f8c27cd81d 100644
--- a/packages/core/src/shared/lsp/utils/cleanup.ts
+++ b/packages/core/src/shared/lsp/utils/cleanup.ts
@@ -23,7 +23,11 @@ function isDelisted(manifestVersions: LspVersion[], targetVersion: string): bool
  * @param downloadDirectory
  * @returns array of deleted versions.
  */
-export async function cleanLspDownloads(manifestVersions: LspVersion[], downloadDirectory: string): Promise<string[]> {
+export async function cleanLspDownloads(
+    latestInstalledVersion: string,
+    manifestVersions: LspVersion[],
+    downloadDirectory: string
+): Promise<string[]> {
     const downloadedVersions = await getDownloadedVersions(downloadDirectory)
     const [delistedVersions, remainingVersions] = partition(downloadedVersions, (v: string) =>
         isDelisted(manifestVersions, v)
@@ -40,6 +44,15 @@ export async function cleanLspDownloads(manifestVersions: LspVersion[], download
     }
 
     for (const v of sort(remainingVersions).slice(0, -2)) {
+        /**
+         * When switching between different manifests, the following edge case can occur:
+         * A newly downloaded version might chronologically be older than all previously downloaded versions,
+         * even though it's marked as the latest version in its own manifest.
+         * In such cases, we skip the cleanup process to preserve this version. Otherwise we will get an EPIPE error
+         */
+        if (v === latestInstalledVersion) {
+            continue
+        }
         await fs.delete(path.join(downloadDirectory, v), { force: true, recursive: true })
         deletedVersions.push(v)
     }
diff --git a/packages/core/src/test/shared/lsp/utils/cleanup.test.ts b/packages/core/src/test/shared/lsp/utils/cleanup.test.ts
index 98f37fff28f..ec2f5a32059 100644
--- a/packages/core/src/test/shared/lsp/utils/cleanup.test.ts
+++ b/packages/core/src/test/shared/lsp/utils/cleanup.test.ts
@@ -41,7 +41,7 @@ describe('cleanLSPDownloads', function () {
 
     it('keeps two newest versions', async function () {
         await fakeInstallVersions(['1.0.0', '1.0.1', '1.1.1', '2.1.1'], installationDir.fsPath)
-        const deleted = await cleanLspDownloads([], installationDir.fsPath)
+        const deleted = await cleanLspDownloads('2.1.1', [], installationDir.fsPath)
 
         const result = (await fs.readdir(installationDir.fsPath)).map(([filename, _filetype], _index) => filename)
         assert.strictEqual(result.length, 2)
@@ -53,6 +53,7 @@ describe('cleanLSPDownloads', function () {
     it('deletes delisted versions', async function () {
         await fakeInstallVersions(['1.0.0', '1.0.1', '1.1.1', '2.1.1'], installationDir.fsPath)
         const deleted = await cleanLspDownloads(
+            '2.1.1',
             [{ serverVersion: '1.1.1', isDelisted: true, targets: [] }],
             installationDir.fsPath
         )
@@ -67,6 +68,7 @@ describe('cleanLSPDownloads', function () {
     it('handles case where less than 2 versions are not delisted', async function () {
         await fakeInstallVersions(['1.0.0', '1.0.1', '1.1.1', '2.1.1'], installationDir.fsPath)
         const deleted = await cleanLspDownloads(
+            '1.0.1',
             [
                 { serverVersion: '1.1.1', isDelisted: true, targets: [] },
                 { serverVersion: '2.1.1', isDelisted: true, targets: [] },
@@ -83,7 +85,7 @@ describe('cleanLSPDownloads', function () {
 
     it('handles case where less than 2 versions exist', async function () {
         await fakeInstallVersions(['1.0.0'], installationDir.fsPath)
-        const deleted = await cleanLspDownloads([], installationDir.fsPath)
+        const deleted = await cleanLspDownloads('1.0.0', [], installationDir.fsPath)
 
         const result = (await fs.readdir(installationDir.fsPath)).map(([filename, _filetype], _index) => filename)
         assert.strictEqual(result.length, 1)
@@ -93,6 +95,7 @@ describe('cleanLSPDownloads', function () {
     it('does not install delisted version when no other option exists', async function () {
         await fakeInstallVersions(['1.0.0'], installationDir.fsPath)
         const deleted = await cleanLspDownloads(
+            '1.0.0',
             [{ serverVersion: '1.0.0', isDelisted: true, targets: [] }],
             installationDir.fsPath
         )
@@ -105,6 +108,7 @@ describe('cleanLSPDownloads', function () {
     it('ignores invalid versions', async function () {
         await fakeInstallVersions(['1.0.0', '.DS_STORE'], installationDir.fsPath)
         const deleted = await cleanLspDownloads(
+            '1.0.0',
             [{ serverVersion: '1.0.0', isDelisted: true, targets: [] }],
             installationDir.fsPath
         )

From 938bb376647414776a55d7dd7d6761c863764c5c Mon Sep 17 00:00:00 2001
From: Josh Pinkney <jpink@amazon.com>
Date: Wed, 16 Apr 2025 19:58:23 -0400
Subject: [PATCH 08/13] feat(amazonq): enable amazon q lsp + chat experiment by
 default

---
 packages/amazonq/src/extension.ts     | 2 +-
 packages/amazonq/src/extensionNode.ts | 2 +-
 packages/amazonq/src/lsp/client.ts    | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/packages/amazonq/src/extension.ts b/packages/amazonq/src/extension.ts
index fe5ce809c9d..345e6e646e3 100644
--- a/packages/amazonq/src/extension.ts
+++ b/packages/amazonq/src/extension.ts
@@ -119,7 +119,7 @@ export async function activateAmazonQCommon(context: vscode.ExtensionContext, is
     }
     // This contains every lsp agnostic things (auth, security scan, code scan)
     await activateCodeWhisperer(extContext as ExtContext)
-    if (Experiments.instance.get('amazonqLSP', false)) {
+    if (Experiments.instance.get('amazonqLSP', true)) {
         await activateAmazonqLsp(context)
     }
 
diff --git a/packages/amazonq/src/extensionNode.ts b/packages/amazonq/src/extensionNode.ts
index d3e98b025e8..5a8b5082c45 100644
--- a/packages/amazonq/src/extensionNode.ts
+++ b/packages/amazonq/src/extensionNode.ts
@@ -53,7 +53,7 @@ async function activateAmazonQNode(context: vscode.ExtensionContext) {
         extensionContext: context,
     }
 
-    if (!Experiments.instance.get('amazonqChatLSP', false)) {
+    if (!Experiments.instance.get('amazonqChatLSP', true)) {
         const appInitContext = DefaultAmazonQAppInitContext.instance
         const provider = new AmazonQChatViewProvider(
             context,
diff --git a/packages/amazonq/src/lsp/client.ts b/packages/amazonq/src/lsp/client.ts
index e45a3fdac83..12341ff17ab 100644
--- a/packages/amazonq/src/lsp/client.ts
+++ b/packages/amazonq/src/lsp/client.ts
@@ -117,7 +117,7 @@ export async function startLanguageServer(
             )
         }
 
-        if (Experiments.instance.get('amazonqChatLSP', false)) {
+        if (Experiments.instance.get('amazonqChatLSP', true)) {
             await activate(client, encryptionKey, resourcePaths.ui)
         }
 

From 756c286c8728b5c5434971ecd58a96a1c56a992b Mon Sep 17 00:00:00 2001
From: Josh Pinkney <jpink@amazon.com>
Date: Wed, 16 Apr 2025 19:59:46 -0400
Subject: [PATCH 09/13] feat(amazonq): use qAgenticChatServer alpha manifest

---
 packages/amazonq/src/lsp/config.ts | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/packages/amazonq/src/lsp/config.ts b/packages/amazonq/src/lsp/config.ts
index 81cc9f59e6e..62bba1ac93d 100644
--- a/packages/amazonq/src/lsp/config.ts
+++ b/packages/amazonq/src/lsp/config.ts
@@ -11,8 +11,8 @@ export interface ExtendedAmazonQLSPConfig extends LspConfig {
 }
 
 export const defaultAmazonQLspConfig: ExtendedAmazonQLSPConfig = {
-    manifestUrl: 'https://d3akiidp1wvqyg.cloudfront.net/codewhisperer/0/manifest.json',
-    supportedVersions: '^3.1.1',
+    manifestUrl: 'https://d3akiidp1wvqyg.cloudfront.net/qAgenticChatServer/0/manifest.json', // TODO swap this back
+    supportedVersions: '*', // TODO swap this back
     id: 'AmazonQ', // used across IDEs for identifying global storage/local disk locations. Do not change.
     suppressPromptPrefix: 'amazonQ',
     path: undefined,

From d206d3b53b599fe42c2e1ce5629a99f72d2bd3b6 Mon Sep 17 00:00:00 2001
From: Josh Pinkney <jpink@amazon.com>
Date: Wed, 16 Apr 2025 20:08:57 -0400
Subject: [PATCH 10/13] fix(amazonq): set amazonq lsp experiment as true by
 default

---
 packages/toolkit/package.json | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/packages/toolkit/package.json b/packages/toolkit/package.json
index b84e3d2ee47..09b9233d9cf 100644
--- a/packages/toolkit/package.json
+++ b/packages/toolkit/package.json
@@ -249,7 +249,7 @@
                         },
                         "amazonqLSP": {
                             "type": "boolean",
-                            "default": false
+                            "default": true
                         },
                         "amazonqLSPInline": {
                             "type": "boolean",
@@ -257,7 +257,7 @@
                         },
                         "amazonqChatLSP": {
                             "type": "boolean",
-                            "default": false
+                            "default": true
                         }
                     },
                     "additionalProperties": false

From 721522ad37671829079252a063a9b8af13894b35 Mon Sep 17 00:00:00 2001
From: Josh Pinkney <jpink@amazon.com>
Date: Thu, 17 Apr 2025 08:43:48 -0400
Subject: [PATCH 11/13] fix(amazonq): duplicate quick actions

---
 packages/amazonq/src/lsp/chat/messages.ts        |  7 ++++---
 packages/amazonq/src/lsp/chat/webviewProvider.ts | 16 +---------------
 packages/amazonq/src/lsp/client.ts               |  1 +
 3 files changed, 6 insertions(+), 18 deletions(-)

diff --git a/packages/amazonq/src/lsp/chat/messages.ts b/packages/amazonq/src/lsp/chat/messages.ts
index 799b6b2ae47..1a9d1078533 100644
--- a/packages/amazonq/src/lsp/chat/messages.ts
+++ b/packages/amazonq/src/lsp/chat/messages.ts
@@ -50,9 +50,10 @@ export function registerLanguageServerEventListener(languageClient: LanguageClie
 
     const chatOptions = languageClient.initializeResult?.awsServerCapabilities?.chatOptions
 
-    // Enable the history/export feature flags
-    chatOptions.history = true
-    chatOptions.export = true
+    // overide the quick action commands provided by flare server initialization, which doesn't provide the group header
+    if (chatOptions?.quickActions?.quickActionsCommandGroups?.[0]) {
+        chatOptions.quickActions.quickActionsCommandGroups[0].groupName = 'Quick Actions'
+    }
 
     provider.onDidResolveWebview(() => {
         void provider.webview?.postMessage({
diff --git a/packages/amazonq/src/lsp/chat/webviewProvider.ts b/packages/amazonq/src/lsp/chat/webviewProvider.ts
index 2c4d5755434..d38e992fdb7 100644
--- a/packages/amazonq/src/lsp/chat/webviewProvider.ts
+++ b/packages/amazonq/src/lsp/chat/webviewProvider.ts
@@ -116,21 +116,7 @@ export class AmazonQChatViewProvider implements WebviewViewProvider {
                 const init = () => {
                     const vscodeApi = acquireVsCodeApi()
                     const hybridChatConnector = new HybridChatAdapter(${(await AuthUtil.instance.getChatAuthState()).amazonQ === 'connected'},${featureConfigData},${welcomeCount},${disclaimerAcknowledged},${regionProfileString},${disabledCommands},${isSMUS},${isSM},vscodeApi.postMessage)
-                    const commands = [hybridChatConnector.initialQuickActions[0], {
-                        groupName: 'Quick Actions',
-                        commands: [
-                            {
-                                command: '/help',
-                                icon: 'help',
-                                description: 'Learn more about Amazon Q',
-                            },
-                            {
-                                command: '/clear',
-                                icon: 'trash',
-                                description: 'Clear this session',
-                            },
-                        ],
-                    }]
+                    const commands = [hybridChatConnector.initialQuickActions[0]]
                     amazonQChat.createChat(vscodeApi, {disclaimerAcknowledged: ${disclaimerAcknowledged}, quickActionCommands: commands}, hybridChatConnector);
                 }
             </script>
diff --git a/packages/amazonq/src/lsp/client.ts b/packages/amazonq/src/lsp/client.ts
index 12341ff17ab..51929e97fda 100644
--- a/packages/amazonq/src/lsp/client.ts
+++ b/packages/amazonq/src/lsp/client.ts
@@ -61,6 +61,7 @@ export async function startLanguageServer(
                 awsClientCapabilities: {
                     window: {
                         notifications: true,
+                        showSaveFileDialog: true,
                     },
                 },
             },

From e0dbbacdd5ad12fce187dec1dfacd717cba11d1f Mon Sep 17 00:00:00 2001
From: Josh Pinkney <jpink@amazon.com>
Date: Thu, 17 Apr 2025 08:57:26 -0400
Subject: [PATCH 12/13] fix(amazonq): acknowledgement is not adding to
 suppressPrompts when pressed

---
 packages/amazonq/src/lsp/chat/messages.ts                       | 2 +-
 packages/core/src/amazonq/webview/messages/messageDispatcher.ts | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/packages/amazonq/src/lsp/chat/messages.ts b/packages/amazonq/src/lsp/chat/messages.ts
index 1a9d1078533..8e4fd2af30f 100644
--- a/packages/amazonq/src/lsp/chat/messages.ts
+++ b/packages/amazonq/src/lsp/chat/messages.ts
@@ -138,7 +138,7 @@ export function registerMessageListeners(
                 break
             }
             case DISCLAIMER_ACKNOWLEDGED: {
-                void AmazonQPromptSettings.instance.disablePrompt('amazonQChatDisclaimer')
+                void AmazonQPromptSettings.instance.update('amazonQChatDisclaimer', true)
                 break
             }
             case chatRequestType.method: {
diff --git a/packages/core/src/amazonq/webview/messages/messageDispatcher.ts b/packages/core/src/amazonq/webview/messages/messageDispatcher.ts
index 10a59c355e1..56d4c8503b9 100644
--- a/packages/core/src/amazonq/webview/messages/messageDispatcher.ts
+++ b/packages/core/src/amazonq/webview/messages/messageDispatcher.ts
@@ -96,7 +96,7 @@ export function handleWebviewEvent(msg: any, webViewToAppsMessagePublishers: Map
             return
         }
         case 'disclaimer-acknowledged': {
-            void AmazonQPromptSettings.instance.disablePrompt('amazonQChatDisclaimer')
+            void AmazonQPromptSettings.instance.update('amazonQChatDisclaimer', true)
             return
         }
         case 'update-welcome-count': {

From d457022377ad804f8a9c99d3f4964123c31deead Mon Sep 17 00:00:00 2001
From: "Justin M. Keyes" <jmkeyes@amazon.com>
Date: Thu, 17 Apr 2025 08:52:08 -0700
Subject: [PATCH 13/13] fix(amazonq): chat disclaimer acknowledgement not
 recognized #7079

---
 packages/amazonq/src/lsp/chat/webviewProvider.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/packages/amazonq/src/lsp/chat/webviewProvider.ts b/packages/amazonq/src/lsp/chat/webviewProvider.ts
index e1eb3215395..ee73a599867 100644
--- a/packages/amazonq/src/lsp/chat/webviewProvider.ts
+++ b/packages/amazonq/src/lsp/chat/webviewProvider.ts
@@ -64,7 +64,7 @@ export class AmazonQChatViewProvider implements WebviewViewProvider {
     }
 
     private async getWebviewContent(mynahUIPath: string) {
-        const disclaimerAcknowledged = AmazonQPromptSettings.instance.isPromptEnabled('amazonQChatDisclaimer')
+        const disclaimerAcknowledged = !AmazonQPromptSettings.instance.isPromptEnabled('amazonQChatDisclaimer')
         return `
         <!DOCTYPE html>
         <html lang="en">