Merge branch 'feature/amazonqLSP-auth' into feature/amazonqLSP-auth

Author: opieter-aws

packages/amazonq/src/lsp/activation.ts

@@ -20,6 +20,6 @@ export async function activate(ctx: vscode.ExtensionContext) {
         await AuthUtil.instance.restore()
     } 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}`)
     }
 }

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,

packages/amazonq/src/lsp/client.ts

@@ -30,13 +30,15 @@ import {
     Experiments,
     Commands,
     openUrl,
+    validateNodeExe,
     getLogger,
 } from 'aws-core-vscode/shared'
 import { activate } from './chat/activation'
 import { AmazonQResourcePaths } from './lspInstaller'
 import { auth2 } from 'aws-core-vscode/auth'
 
 const localize = nls.loadMessageBundle()
+const logger = getLogger('amazonqLsp.lspClient')
 
 export const clientId = 'amazonq'
 export const clientName = oidcClientName()
@@ -50,22 +52,25 @@ 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: '*' }]
     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

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()
     })

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'

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,
@@ -39,12 +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'
 
 const localize = nls.loadMessageBundle()
 
 const key = crypto.randomBytes(32)
+const logger = getLogger('amazonqWorkspaceLsp')
 
 /**
  * LspClient manages the API call between VS Code extension and LSP server
@@ -80,7 +81,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 +96,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 +112,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 +133,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 +145,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 +158,7 @@ export class LspClient {
             )
             return resp
         } catch (e) {
-            getLogger().error(`LspClient: queryInlineProjectContext error: ${e}`)
+            logger.error(`queryInlineProjectContext error: ${e}`)
             throw e
         }
     }
@@ -174,7 +175,7 @@ export class LspClient {
             )
             return resp
         } catch (e) {
-            getLogger().error(`LspClient: getContextCommandItems error: ${e}`)
+            logger.error(`getContextCommandItems error: ${e}`)
             throw e
         }
     }
@@ -190,7 +191,7 @@ export class LspClient {
             )
             return resp || []
         } catch (e) {
-            getLogger().error(`LspClient: getContextCommandPrompt error: ${e}`)
+            logger.error(`getContextCommandPrompt error: ${e}`)
             throw e
         }
     }
@@ -204,7 +205,7 @@ export class LspClient {
             )
             return resp
         } catch (e) {
-            getLogger().error(`LspClient: getIndexSequenceNumber error: ${e}`)
+            logger.error(`getIndexSequenceNumber error: ${e}`)
             throw e
         }
     }
@@ -222,20 +223,20 @@ 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.
+ * 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()
 
@@ -252,22 +253,18 @@ 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 },
-    }
-
-    serverOptions = createServerOptions({
+    const serverOptions = createServerOptions({
         encryptionKey: key,
         executable: resourcePaths.node,
         serverModule,
+        // TODO(jmkeyes): we always use the debug options...?
         execArgv: debugOptions.execArgv,
     })
 
     const documentSelector = [{ scheme: 'file', language: '*' }]
 
+    await validateNodeExe(resourcePaths.node, resourcePaths.lsp, debugOptions.execArgv, logger)
+
     // Options to control the language client
     const clientOptions: LanguageClientOptions = {
         // Register the server for json documents
@@ -359,10 +356,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> {

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,15 +223,15 @@ 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`)
         }
     }
 
     private async setupLsp(context: vscode.ExtensionContext) {
         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')
         })
     }
 }