refactor(amazonq): Improve robustness of lsp installation process

packages/amazonq/src/lsp/activation.ts

@@ -7,16 +7,11 @@ import vscode from 'vscode'
 import { startLanguageServer } from './client'
 import { AmazonQLSPResolver } from './lspInstaller'
 import { ToolkitError } from 'aws-core-vscode/shared'
-import path from 'path'
 
 export async function activate(ctx: vscode.ExtensionContext): Promise<void> {
     try {
         const installResult = await new AmazonQLSPResolver().resolve()
-        const serverLocation =
-            installResult.location === 'override'
-                ? installResult.assetDirectory
-                : path.join(installResult.assetDirectory, 'servers/aws-lsp-codewhisperer.js')
-        await startLanguageServer(ctx, serverLocation)
+        await startLanguageServer(ctx, installResult.executablePaths)
     } catch (err) {
         const e = err as ToolkitError
         void vscode.window.showInformationMessage(`Unable to launch amazonq language server: ${e.message}`)

packages/amazonq/src/lsp/client.ts

@@ -12,10 +12,11 @@ import { registerInlineCompletion } from '../inline/completion'
 import { AmazonQLspAuth, notificationTypes, writeEncryptionInit } from './auth'
 import { AuthUtil } from 'aws-core-vscode/codewhisperer'
 import { ConnectionMetadata } from '@aws/language-server-runtimes/protocol'
+import { ExecutablePaths } from 'aws-core-vscode/shared'
 
 const localize = nls.loadMessageBundle()
 
-export function startLanguageServer(extensionContext: vscode.ExtensionContext, serverPath: string) {
+export function startLanguageServer(extensionContext: vscode.ExtensionContext, executablePaths: ExecutablePaths) {
     const toDispose = extensionContext.subscriptions
 
     // The debug options for the server
@@ -30,14 +31,16 @@ export function startLanguageServer(extensionContext: vscode.ExtensionContext, s
         ],
     }
 
+    const serverPath = executablePaths.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: serverPath, transport: TransportKind.ipc },
         debug: { module: serverPath, transport: TransportKind.ipc, options: debugOptions },
     }
 
-    const child = cp.spawn('node', [serverPath, ...debugOptions.execArgv])
+    const child = cp.spawn(executablePaths.node, [serverPath, ...debugOptions.execArgv])
     writeEncryptionInit(child.stdin)
 
     serverOptions = () => Promise.resolve(child)

packages/amazonq/src/lsp/lspInstaller.ts

@@ -5,20 +5,32 @@
 
 import * as vscode from 'vscode'
 import { Range } from 'semver'
-import { ManifestResolver, LanguageServerResolver, LspResolver, LspResult } from 'aws-core-vscode/shared'
+import {
+    ManifestResolver,
+    LanguageServerResolver,
+    LspResolver,
+    fs,
+    LspResolution,
+    getNodeExecutableName,
+} from 'aws-core-vscode/shared'
+import path from 'path'
 
 const manifestURL = 'https://aws-toolkit-language-servers.amazonaws.com/codewhisperer/0/manifest.json'
 export const supportedLspServerVersions = '^2.3.0'
 
 export class AmazonQLSPResolver implements LspResolver {
-    async resolve(): Promise<LspResult> {
+    async resolve(): Promise<LspResolution> {
         const overrideLocation = process.env.AWS_LANGUAGE_SERVER_OVERRIDE
         if (overrideLocation) {
             void vscode.window.showInformationMessage(`Using language server override location: ${overrideLocation}`)
             return {
                 assetDirectory: overrideLocation,
                 location: 'override',
                 version: '0.0.0',
+                executablePaths: {
+                    lsp: overrideLocation,
+                    node: getNodeExecutableName(),
+                },
             }
         }
 
@@ -31,7 +43,16 @@ export class AmazonQLSPResolver implements LspResolver {
             new Range(supportedLspServerVersions)
         ).resolve()
 
+        const nodePath = path.join(installationResult.assetDirectory, `servers/${getNodeExecutableName()}`)
+        await fs.chmod(nodePath, 0o755)
+
         // TODO Cleanup old versions of language servers
-        return installationResult
+        return {
+            ...installationResult,
+            executablePaths: {
+                lsp: path.join(installationResult.assetDirectory, 'servers/aws-lsp-codewhisperer.js'),
+                node: nodePath,
+            },
+        }
     }
 }

packages/core/src/amazonq/lsp/lspClient.ts

@@ -32,7 +32,7 @@ import {
 } from './types'
 import { Writable } from 'stream'
 import { CodeWhispererSettings } from '../../codewhisperer/util/codewhispererSettings'
-import { fs, getLogger, globals } from '../../shared'
+import { ExecutablePaths, fs, getLogger, globals } from '../../shared'
 
 const localize = nls.loadMessageBundle()
 
@@ -172,7 +172,7 @@ export class LspClient {
  * It will create a output channel named Amazon Q Language Server.
  * This function assumes the LSP server has already been downloaded.
  */
-export async function activate(extensionContext: ExtensionContext, serverModule: string) {
+export async function activate(extensionContext: ExtensionContext, executablePaths: ExecutablePaths) {
     LspClient.instance
     const toDispose = extensionContext.subscriptions
 
@@ -195,12 +195,9 @@ export async function activate(extensionContext: ExtensionContext, serverModule:
         delete process.env.Q_WORKER_THREADS
     }
 
-    const nodename = process.platform === 'win32' ? 'node.exe' : 'node'
+    const serverModule = executablePaths.lsp
 
-    const child = spawn(extensionContext.asAbsolutePath(path.join('resources', nodename)), [
-        serverModule,
-        ...debugOptions.execArgv,
-    ])
+    const child = spawn(executablePaths.node, [serverModule, ...debugOptions.execArgv])
     // share an encryption key using stdin
     // follow same practice of DEXP LSP server
     writeEncryptionInit(child.stdin)

packages/core/src/amazonq/lsp/lspController.ts

@@ -161,7 +161,7 @@ export class LspController {
         setImmediate(async () => {
             try {
                 const installResult = await new WorkspaceLSPResolver().resolve()
-                await activateLsp(context, path.join(installResult.assetDirectory, 'resources/qserver/lspServer.js'))
+                await activateLsp(context, installResult.executablePaths)
                 getLogger().info('LspController: LSP activated')
                 void LspController.instance.buildIndex(buildIndexConfig)
                 // log the LSP server CPU and Memory usage per 30 minutes.

packages/core/src/amazonq/lsp/workspaceInstaller.ts

@@ -3,17 +3,20 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import { LspResolver, LspResult } from '../../shared/languageServer/types'
+import path from 'path'
+import { LspResolution, LspResolver } from '../../shared/languageServer/types'
 import { ManifestResolver } from '../../shared/languageServer/manifestResolver'
 import { LanguageServerResolver } from '../../shared/languageServer/lspResolver'
 import { Range } from 'semver'
+import { getNodeExecutableName } from '../../shared/languageServer/utils/platform'
+import { fs } from '../../shared/fs/fs'
 
 const manifestUrl = 'https://aws-toolkit-language-servers.amazonaws.com/q-context/manifest.json'
 // this LSP client in Q extension is only going to work with these LSP server versions
 const supportedLspServerVersions = '0.1.32'
 
 export class WorkspaceLSPResolver implements LspResolver {
-    async resolve(): Promise<LspResult> {
+    async resolve(): Promise<LspResolution> {
         const name = 'AmazonQ-Workspace'
         const manifest = await new ManifestResolver(manifestUrl, name).resolve()
         const installationResult = await new LanguageServerResolver(
@@ -22,7 +25,21 @@ export class WorkspaceLSPResolver implements LspResolver {
             new Range(supportedLspServerVersions)
         ).resolve()
 
+        const nodeName =
+            process.platform === 'win32' ? getNodeExecutableName() : `node-${process.platform}-${process.arch}`
+        const nodePath = path.join(installationResult.assetDirectory, nodeName)
+        await fs.chmod(nodePath, 0o755)
+
         // TODO Cleanup old versions of language servers
-        return installationResult
+        return {
+            ...installationResult,
+            executablePaths: {
+                lsp: path.join(
+                    installationResult.assetDirectory,
+                    `qserver-${process.platform}-${process.arch}/qserver/lspServer.js`
+                ),
+                node: nodePath,
+            },
+        }
     }
 }

packages/core/src/shared/index.ts

@@ -63,3 +63,4 @@ export * from './languageServer/manifestResolver'
 export * from './languageServer/lspResolver'
 export * from './languageServer/types'
 export { default as request } from './request'
+export * from './languageServer/utils/platform'

packages/core/src/shared/languageServer/types.ts

@@ -15,8 +15,16 @@ export interface LspResult {
     assetDirectory: string
 }
 
+export interface ExecutablePaths {
+    lsp: string
+    node: string
+}
+export interface LspResolution extends LspResult {
+    executablePaths: ExecutablePaths
+}
+
 export interface LspResolver {
-    resolve(): Promise<LspResult>
+    resolve(): Promise<LspResolution>
 }
 
 export interface TargetContent {

packages/core/src/shared/languageServer/utils/platform.ts

@@ -0,0 +1,8 @@
+/*!
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+export function getNodeExecutableName(): string {
+    return process.platform === 'win32' ? 'node.exe' : 'node'
+}