Merge branch 'aws:master' into master

laileni-aws · web-flow · commit 8045bb6749f6 · 2025-05-08T20:21:51.000-07:00
diff --git a/packages/amazonq/.changes/next-release/Bug Fix-75375702-36b5-4e89-af57-4afe983a7238.json b/packages/amazonq/.changes/next-release/Bug Fix-75375702-36b5-4e89-af57-4afe983a7238.json
@@ -0,0 +1,4 @@
+{
+	"type": "Bug Fix",
+	"description": "Avoid inline completion 'Improperly formed request' errors when file is too large"
+}
diff --git a/packages/amazonq/.changes/next-release/Bug Fix-b873a959-2742-4440-badc-c90c6ac754c3.json b/packages/amazonq/.changes/next-release/Bug Fix-b873a959-2742-4440-badc-c90c6ac754c3.json
@@ -0,0 +1,4 @@
+{
+	"type": "Bug Fix",
+	"description": "Named agent tabs sometimes open with unnecessary input options"
+}
diff --git a/packages/amazonq/src/lsp/client.ts b/packages/amazonq/src/lsp/client.ts
@@ -5,7 +5,6 @@
 
 import vscode, { env, version } from 'vscode'
 import * as nls from 'vscode-nls'
-import * as crypto from 'crypto'
 import { LanguageClient, LanguageClientOptions, RequestType, State } from 'vscode-languageclient'
 import { InlineCompletionManager } from '../app/inline/completion'
 import { AmazonQLspAuth, encryptionKey, notificationTypes } from './auth'
@@ -34,6 +33,7 @@ import {
     getOptOutPreference,
     isAmazonInternalOs,
     fs,
+    getClientId,
 } from 'aws-core-vscode/shared'
 import { processUtils } from 'aws-core-vscode/shared'
 import { activate } from './chat/activation'
@@ -120,7 +120,7 @@ export async function startLanguageServer(
                         name: 'AmazonQ-For-VSCode',
                         version: '0.0.1',
                     },
-                    clientId: crypto.randomUUID(),
+                    clientId: getClientId(globals.globalState),
                 },
                 awsClientCapabilities: {
                     q: {
@@ -131,6 +131,9 @@ export async function startLanguageServer(
                         showSaveFileDialog: true,
                     },
                 },
+                contextConfiguration: {
+                    workspaceIdentifier: extensionContext.storageUri,
+                },
                 logLevel: toAmazonQLSPLogLevel(globals.logOutputChannel.logLevel),
             },
             credentials: {
diff --git a/packages/amazonq/test/e2e/lsp/lspInstallerUtil.ts b/packages/amazonq/test/e2e/lsp/lspInstallerUtil.ts
@@ -14,6 +14,7 @@ import {
     ManifestResolver,
     request,
     TargetContent,
+    ToolkitError,
 } from 'aws-core-vscode/shared'
 import * as semver from 'semver'
 import { assertTelemetry } from 'aws-core-vscode/test'
@@ -201,12 +202,6 @@ export function createLspInstallerTests({
                         id: lspConfig.id,
                         manifestLocation: 'remote',
                         languageServerSetupStage: 'getManifest',
-                        result: 'Failed',
-                    },
-                    {
-                        id: lspConfig.id,
-                        manifestLocation: 'cache',
-                        languageServerSetupStage: 'getManifest',
                         result: 'Succeeded',
                     },
                     {
@@ -282,6 +277,34 @@ export function createLspInstallerTests({
                 const download = await createInstaller(lspConfig).resolve()
                 assert.ok(download.assetDirectory.endsWith('-rc.0'))
             })
+
+            it('throws on firewall error', async () => {
+                // Stub the manifest resolver to return a valid manifest
+                sandbox.stub(ManifestResolver.prototype, 'resolve').resolves({
+                    manifestSchemaVersion: '0.0.0',
+                    artifactId: 'foo',
+                    artifactDescription: 'foo',
+                    isManifestDeprecated: false,
+                    versions: [createVersion('1.0.0', targetContents)],
+                })
+
+                // Fail all HTTP requests for the language server
+                sandbox.stub(request, 'fetch').returns({
+                    response: Promise.resolve({
+                        ok: false,
+                    }),
+                } as any)
+
+                // This should now throw a NetworkConnectivityError
+                await assert.rejects(
+                    async () => await installer.resolve(),
+                    (err: ToolkitError) => {
+                        assert.strictEqual(err.code, 'NetworkConnectivityError')
+                        assert.ok(err.message.includes('Unable to download dependencies'))
+                        return true
+                    }
+                )
+            })
         })
     })
 }
diff --git a/packages/amazonq/test/unit/codewhisperer/util/runtimeLanguageContext.test.ts b/packages/amazonq/test/unit/codewhisperer/util/runtimeLanguageContext.test.ts
@@ -4,13 +4,18 @@
  */
 
 import assert from 'assert'
-import { resetCodeWhispererGlobalVariables, toTextDocument } from 'aws-core-vscode/test'
+import { resetCodeWhispererGlobalVariables, TestFolder, toTextDocument } from 'aws-core-vscode/test'
 import { runtimeLanguageContext, RuntimeLanguageContext, PlatformLanguageId } from 'aws-core-vscode/codewhisperer'
 import * as codewhispererClient from 'aws-core-vscode/codewhisperer'
 import { CodewhispererLanguage } from 'aws-core-vscode/shared'
 
 describe('runtimeLanguageContext', function () {
     const languageContext = new RuntimeLanguageContext()
+    let tempFolder: TestFolder
+
+    before(async function () {
+        tempFolder = await TestFolder.create()
+    })
 
     describe('test isLanguageSupported', function () {
         const cases: [string, boolean][] = [
@@ -104,13 +109,12 @@ describe('runtimeLanguageContext', function () {
                 ['helloUnknown', false],
                 ['helloFoo.foo', false],
             ]
-
             for (const tuple of cases) {
                 const fileName = tuple[0]
                 const expected = tuple[1]
 
                 it(`pass document ${fileName} as argument should first try determine by languageId then file extensions`, async function () {
-                    const doc = await toTextDocument('', fileName)
+                    const doc = await toTextDocument('', fileName, tempFolder.path)
                     const actual = languageContext.isLanguageSupported(doc)
                     assert.strictEqual(actual, expected)
                 })
diff --git a/packages/core/src/amazonq/webview/ui/quickActions/handler.ts b/packages/core/src/amazonq/webview/ui/quickActions/handler.ts
@@ -355,6 +355,8 @@ export class QuickActionHandler {
                 loadingChat: true,
                 cancelButtonWhenLoading: false,
             })
+        } else {
+            this.mynahUI.updateStore(affectedTabId, { promptInputOptions: [] })
         }
 
         if (affectedTabId && this.isHybridChatEnabled) {
diff --git a/packages/core/src/codewhisperer/models/constants.ts b/packages/core/src/codewhisperer/models/constants.ts
@@ -87,6 +87,9 @@ export const lineBreakWin = '\r\n'
 export const supplementalContextTimeoutInMs = 100
 
 export const supplementalContextMaxTotalLength = 20480
+
+export const editorStateMaxLength = 40000
+
 /**
  * Ux of recommendations
  */
diff --git a/packages/core/src/codewhisperer/util/customizationUtil.ts b/packages/core/src/codewhisperer/util/customizationUtil.ts
@@ -59,7 +59,7 @@ export const onProfileChangedListener: (event: ProfileChangedEvent) => any = asy
     if (event.intent === 'customization') {
         return
     }
-
+    const logger = getLogger()
     if (!event.profile) {
         await setSelectedCustomization(baseCustomization)
         return
@@ -69,7 +69,16 @@ export const onProfileChangedListener: (event: ProfileChangedEvent) => any = asy
     const selectedCustomization = getSelectedCustomization()
     // No need to validate base customization which has empty arn.
     if (selectedCustomization.arn.length > 0) {
-        await switchToBaseCustomizationAndNotify()
+        const customizationProvider = await CustomizationProvider.init(event.profile)
+        const customizations = await customizationProvider.listAvailableCustomizations()
+
+        const r = customizations.find((it) => it.arn === selectedCustomization.arn)
+        if (!r) {
+            logger.debug(
+                `profile ${event.profile.name} doesnt have access to customization ${selectedCustomization.name} but has access to ${customizations.map((it) => it.name)}`
+            )
+            await switchToBaseCustomizationAndNotify()
+        }
     }
 }
 
diff --git a/packages/core/src/codewhisperer/util/editorContext.ts b/packages/core/src/codewhisperer/util/editorContext.ts
@@ -8,10 +8,11 @@ import * as codewhispererClient from '../client/codewhisperer'
 import * as path from 'path'
 import * as CodeWhispererConstants from '../models/constants'
 import { getTabSizeSetting } from '../../shared/utilities/editorUtilities'
+import { truncate } from '../../shared/utilities/textUtilities'
 import { getLogger } from '../../shared/logger/logger'
 import { runtimeLanguageContext } from './runtimeLanguageContext'
 import { fetchSupplementalContext } from './supplementalContext/supplementalContextUtil'
-import { supplementalContextTimeoutInMs } from '../models/constants'
+import { editorStateMaxLength, supplementalContextTimeoutInMs } from '../models/constants'
 import { getSelectedCustomization } from './customizationUtil'
 import { selectFrom } from '../../shared/utilities/tsUtils'
 import { checkLeftContextKeywordsForJson } from './commonUtil'
@@ -216,13 +217,29 @@ export function getTabSize(): number {
 
 export function getEditorState(editor: vscode.TextEditor, fileContext: codewhispererClient.FileContext): any {
     try {
+        const cursorPosition = editor.selection.active
+        const cursorOffset = editor.document.offsetAt(cursorPosition)
+        const documentText = editor.document.getText()
+
+        // Truncate if document content is too large (defined in constants.ts)
+        let fileText = documentText
+        if (documentText.length > editorStateMaxLength) {
+            const halfLength = Math.floor(editorStateMaxLength / 2)
+
+            // Use truncate function to get the text around the cursor position
+            const leftPart = truncate(documentText.substring(0, cursorOffset), -halfLength, '')
+            const rightPart = truncate(documentText.substring(cursorOffset), halfLength, '')
+
+            fileText = leftPart + rightPart
+        }
+
         return {
             document: {
                 programmingLanguage: {
                     languageName: fileContext.programmingLanguage.languageName,
                 },
                 relativeFilePath: fileContext.filename,
-                text: editor.document.getText(),
+                text: fileText,
             },
             cursorState: {
                 position: {
diff --git a/packages/core/src/shared/lsp/baseLspInstaller.ts b/packages/core/src/shared/lsp/baseLspInstaller.ts
@@ -45,6 +45,7 @@ export abstract class BaseLspInstaller<T extends ResourcePaths = ResourcePaths,
             new Range(supportedVersions, {
                 includePrerelease: true,
             }),
+            manifestUrl,
             this.downloadMessageOverride
         ).resolve()
 
diff --git a/packages/core/src/shared/lsp/lspResolver.ts b/packages/core/src/shared/lsp/lspResolver.ts
@@ -29,6 +29,7 @@ export class LanguageServerResolver {
         private readonly manifest: Manifest,
         private readonly lsName: string,
         private readonly versionRange: semver.Range,
+        private readonly manifestUrl: string,
         /**
          * Custom message to show user when downloading, if undefined it will use the default.
          */
@@ -90,7 +91,22 @@ export class LanguageServerResolver {
 
     /** Finds an older, cached version of the LSP server bundle. */
     private async getFallbackServer(latestVersion: LspVersion): Promise<LspResult> {
-        const fallbackDirectory = await this.getFallbackDir(latestVersion.serverVersion)
+        const cachedVersions = await this.getCachedVersions()
+        if (cachedVersions.length === 0) {
+            /**
+             * at this point the latest version doesn't exist locally, lsp download (with retries) failed, and there are no cached fallback versions.
+             * This _probably_ only happens when the user hit a firewall/proxy issue, since otherwise they would probably have at least
+             * one other language server locally
+             */
+            throw new ToolkitError(
+                `Unable to download dependencies from ${this.manifestUrl}. Check your network connectivity or firewall configuration and then try again.`,
+                {
+                    code: 'NetworkConnectivityError',
+                }
+            )
+        }
+
+        const fallbackDirectory = await this.getFallbackDir(latestVersion.serverVersion, cachedVersions)
         if (!fallbackDirectory) {
             throw new ToolkitError('Unable to find a compatible version of the Language Server', {
                 code: 'IncompatibleVersion',
@@ -142,13 +158,22 @@ export class LanguageServerResolver {
                     assetDirectory: cacheDirectory,
                 }
             } else {
+                await this.cleanupVersion(latestVersion.serverVersion)
                 throw new ToolkitError('Failed to download server from remote', { code: 'RemoteDownloadFailed' })
             }
         } finally {
             timeout.dispose()
         }
     }
 
+    private async cleanupVersion(version: string) {
+        // clean up the X.X.X download directory since the download failed
+        const downloadDirectory = this.getDownloadDirectory(version)
+        if (await fs.existsDir(downloadDirectory)) {
+            await fs.delete(downloadDirectory)
+        }
+    }
+
     /** Gets the current local ("cached") LSP server bundle. */
     private async getLocalServer(
         cacheDirectory: string,
@@ -178,16 +203,9 @@ export class LanguageServerResolver {
     /**
      * Returns the path to the most compatible cached LSP version that can serve as a fallback
      **/
-    private async getFallbackDir(version: string) {
+    private async getFallbackDir(version: string, cachedVersions: string[]) {
         const compatibleLspVersions = this.compatibleManifestLspVersion()
 
-        // determine all folders containing lsp versions in the fallback parent folder
-        const cachedVersions = (await fs.readdir(this.defaultDownloadFolder()))
-            .filter(([_, filetype]) => filetype === FileType.Directory)
-            .map(([pathName, _]) => semver.parse(pathName))
-            .filter((ver): ver is semver.SemVer => ver !== null)
-            .map((x) => x.version)
-
         const expectedVersion = semver.parse(version)
         if (!expectedVersion) {
             return undefined
@@ -203,6 +221,15 @@ export class LanguageServerResolver {
         return fallbackDir.length > 0 ? fallbackDir[0] : undefined
     }
 
+    private async getCachedVersions() {
+        // determine all folders containing lsp versions in the parent folder
+        return (await fs.readdir(this.defaultDownloadFolder()))
+            .filter(([_, filetype]) => filetype === FileType.Directory)
+            .map(([pathName, _]) => semver.parse(pathName))
+            .filter((ver): ver is semver.SemVer => ver !== null)
+            .map((x) => x.version)
+    }
+
     /**
      * Validate the local cache directory of the given lsp version (matches expected hash)
      * If valid return cache directory, else return undefined
diff --git a/packages/core/src/shared/lsp/manifestResolver.ts b/packages/core/src/shared/lsp/manifestResolver.ts
@@ -69,7 +69,6 @@ export class ManifestResolver {
 
             const localManifest = await this.getLocalManifest(true).catch(() => undefined)
             if (localManifest) {
-                localManifest.location = 'remote'
                 return localManifest
             } else {
                 // Will emit a `languageServer_setup` result=failed metric...
diff --git a/packages/core/src/shared/lsp/utils/platform.ts b/packages/core/src/shared/lsp/utils/platform.ts
@@ -40,7 +40,7 @@ export async function validateNodeExe(nodePath: string[], lsp: string, args: str
     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}`)
+        throw new ToolkitError(`amazonqLsp: ${msg}`, { code: 'FailedToRunNode' })
     }
 
     // Check that we can start `node …/lsp.js --stdio …`.
@@ -68,7 +68,8 @@ export async function validateNodeExe(nodePath: string[], lsp: string, args: str
         })
         if (!ok2 || selfExit) {
             throw new ToolkitError(
-                `amazonqLsp: failed to run (exitcode=${lspProc.exitCode()}): ${lspProc.toString(false, true)}`
+                `amazonqLsp: failed to run (exitcode=${lspProc.exitCode()}): ${lspProc.toString(false, true)}`,
+                { code: 'FailedToStartLanguageServer' }
             )
         }
     } finally {

-Original file line number
+Diff line change
@@ @@ -0,0 +1,4 @@ @@
 +{
 +	"type": "Bug Fix",
 +	"description": "Avoid inline completion 'Improperly formed request' errors when file is too large"
 +}
Original file line number	Diff line number	Diff line change
`@@ -355,6 +355,8 @@ export class QuickActionHandler {`
`355`	`355`	`loadingChat: true,`
`356`	`356`	`cancelButtonWhenLoading: false,`
`357`	`357`	`})`
	`358`	`+ } else {`
	`359`	`+ this.mynahUI.updateStore(affectedTabId, { promptInputOptions: [] })`
`358`	`360`	`}`
`359`	`361`
`360`	`362`	`if (affectedTabId && this.isHybridChatEnabled) {`