fix(codewhisperer): remove deprecated code #3482

Problem:
Plugin occasionally runs into the deprecated code path in CodeWhisperer, causing bugs and unexpected errors. 
Example:
1. User may see `requested operation is not recognized by the service`. This is because the deprecated code path invokes a deprecated API. 

Solution:
Remove the deprecated code path: 
1. The custom `editor.edit` API based inline completion.
2. The old, deprecated cognito identity authentication.

Author: leigaol

.changes/next-release/Bug Fix-cd94b34d-6abf-4229-9177-8e7ecb8c1e6b.json

@@ -0,0 +1,4 @@
+{
+	"type": "Bug Fix",
+	"description": "CodeWhisperer: Requested operation is not recognized by the service when fetching recommendations"
+}

package.json

@@ -3159,30 +3159,12 @@
                 "mac": "alt+c",
                 "when": "editorTextFocus"
             },
-            {
-                "command": "aws.codeWhisperer.nextCodeSuggestion",
-                "key": "right",
-                "mac": "right",
-                "when": "editorTextFocus && CODEWHISPERER_SERVICE_ACTIVE"
-            },
-            {
-                "command": "aws.codeWhisperer.previousCodeSuggestion",
-                "key": "left",
-                "mac": "left",
-                "when": "editorTextFocus && CODEWHISPERER_SERVICE_ACTIVE"
-            },
             {
                 "command": "aws.codeWhisperer.rejectCodeSuggestion",
                 "key": "escape",
                 "mac": "escape",
                 "when": "inlineSuggestionVisible && !editorReadonly && CODEWHISPERER_ENABLED"
             },
-            {
-                "command": "aws.codeWhisperer.acceptCodeSuggestion",
-                "key": "tab",
-                "mac": "tab",
-                "when": "editorTextFocus && CODEWHISPERER_SERVICE_ACTIVE"
-            },
             {
                 "key": "right",
                 "command": "editor.action.inlineSuggest.showNext",

src/codewhisperer/activation.ts

@@ -10,7 +10,6 @@ import * as EditorContext from './util/editorContext'
 import * as CodeWhispererConstants from './models/constants'
 import { getCompletionItems } from './service/completionProvider'
 import { vsCodeState, ConfigurationEntry } from './models/model'
-import { InlineCompletion } from './service/inlineCompletion'
 import { invokeRecommendation } from './commands/invokeRecommendation'
 import { acceptSuggestion } from './commands/onInlineAcceptance'
 import { resetIntelliSenseState } from './util/globalStateUtil'
@@ -32,7 +31,6 @@ import {
     showFreeTierLimit,
     updateReferenceLog,
     showIntroduction,
-    showAccessTokenErrorLearnMore,
     reconnect,
     refreshStatusBar,
 } from './commands/basicCommands'
@@ -48,8 +46,6 @@ import { InlineCompletionService } from './service/inlineCompletionService'
 import { isInlineCompletionEnabled } from './util/commonUtil'
 import { CodeWhispererCodeCoverageTracker } from './tracker/codewhispererCodeCoverageTracker'
 import { AuthUtil } from './util/authUtil'
-import { Auth } from '../credentials/auth'
-import globals from '../shared/extensionGlobals'
 import { ImportAdderProvider } from './service/importAdderProvider'
 import { TelemetryHelper } from './util/telemetryHelper'
 
@@ -161,8 +157,6 @@ export async function activate(context: ExtContext): Promise<void> {
         reconnect.register(),
         // learn more about CodeWhisperer
         showLearnMore.register(),
-        // learn more about CodeWhisperer access token migration
-        showAccessTokenErrorLearnMore.register(),
         // show free tier limit
         showFreeTierLimit.register(),
         // update reference log instance
@@ -230,63 +224,6 @@ export async function activate(context: ExtContext): Promise<void> {
         }
     }
 
-    async function showAccessTokenMigrationDialogue() {
-        // TODO: Change the color of the buttons
-        const accessTokenExpired =
-            context.extensionContext.globalState.get<boolean>(CodeWhispererConstants.accessTokenExpriedKey) || false
-
-        if (AuthUtil.instance.hasAccessToken()) {
-            await Auth.instance.tryAutoConnect()
-            await globals.context.globalState.update(CodeWhispererConstants.accessToken, undefined)
-            await globals.context.globalState.update(CodeWhispererConstants.accessTokenExpriedKey, true)
-            await vscode.commands.executeCommand('aws.codeWhisperer.refreshRootNode')
-            maybeShowTokenMigrationError()
-        } else if (accessTokenExpired) {
-            maybeShowTokenMigrationError()
-        }
-    }
-
-    function maybeShowTokenMigrationError() {
-        const migrationErrordoNotShowAgain =
-            context.extensionContext.globalState.get<boolean>(
-                CodeWhispererConstants.accessTokenExpiredDoNotShowAgainKey
-            ) || false
-        const migrationErrorLastShown: number =
-            context.extensionContext.globalState.get<number | undefined>(
-                CodeWhispererConstants.accessTokenExpiredDoNotShowLastShown
-            ) || 1
-
-        //Add 7 days to notificationLastShown to determine whether warn message should show
-        if (migrationErrordoNotShowAgain || migrationErrorLastShown + 1000 * 60 * 60 * 24 * 7 >= Date.now()) {
-            return
-        }
-
-        vscode.window
-            .showErrorMessage(
-                CodeWhispererConstants.accessTokenMigrationErrorMessage,
-                CodeWhispererConstants.accessTokenMigrationErrorButtonMessage,
-                CodeWhispererConstants.accessTokenMigrationLearnMore,
-                CodeWhispererConstants.DoNotShowAgain
-            )
-            .then(async resp => {
-                if (resp === CodeWhispererConstants.accessTokenMigrationErrorButtonMessage) {
-                    await vscode.commands.executeCommand('aws.codeWhisperer.refresh')
-                    await showSsoSignIn.execute()
-                } else if (resp === CodeWhispererConstants.DoNotShowAgain) {
-                    await context.extensionContext.globalState.update(
-                        CodeWhispererConstants.accessTokenExpiredDoNotShowAgainKey,
-                        true
-                    )
-                } else if (resp === CodeWhispererConstants.accessTokenMigrationLearnMore) {
-                    await vscode.commands.executeCommand('aws.codeWhisperer.accessTokenErrorLearnMore')
-                }
-            })
-        context.extensionContext.globalState.update(
-            CodeWhispererConstants.accessTokenExpiredDoNotShowLastShown,
-            Date.now()
-        )
-    }
-
     function getAutoTriggerStatus(): boolean {
         return context.extensionContext.globalState.get<boolean>(CodeWhispererConstants.autoTriggerEnabledKey) || false
     }
@@ -312,11 +249,6 @@ export async function activate(context: ExtContext): Promise<void> {
     } else if (isInlineCompletionEnabled()) {
         await setSubscriptionsforInlineCompletion()
         await vscode.commands.executeCommand('setContext', 'CODEWHISPERER_ENABLED', true)
-    } else {
-        await setSubscriptionsforVsCodeInline()
-    }
-    if (!isCloud9()) {
-        showAccessTokenMigrationDialogue()
     }
 
     async function setSubscriptionsforInlineCompletion() {
@@ -379,106 +311,6 @@ export async function activate(context: ExtContext): Promise<void> {
         )
     }
 
-    async function setSubscriptionsforVsCodeInline() {
-        /**
-         * Automated trigger
-         */
-        context.extensionContext.subscriptions.push(
-            vscode.workspace.onDidChangeTextDocument(async e => {
-                /**
-                 * CodeWhisperer security panel dynamic handling
-                 */
-                if (e.document === vscode.window.activeTextEditor?.document) {
-                    if (isCloud9()) {
-                        securityPanelViewProvider.disposeSecurityPanelItem(e, vscode.window.activeTextEditor)
-                    } else {
-                        disposeSecurityDiagnostic(e)
-                    }
-                }
-
-                const codeCoverageTracker = CodeWhispererCodeCoverageTracker.getTracker(e.document.languageId)
-                codeCoverageTracker?.countTotalTokens(e)
-
-                /**
-                 * Handle this keystroke event only when
-                 * 1. It is in current active editor with cwspr supported file types
-                 * 2. It is not a backspace
-                 * 3. It is not caused by CodeWhisperer editing
-                 * 4. It is not from undo/redo.
-                 */
-                if (
-                    e.document === vscode.window.activeTextEditor?.document &&
-                    runtimeLanguageContext.isLanguageSupported(e.document.languageId) &&
-                    e.contentChanges.length != 0 &&
-                    !vsCodeState.isCodeWhispererEditing &&
-                    !JSON.stringify(e).includes('reason')
-                ) {
-                    vsCodeState.lastUserModificationTime = performance.now()
-                    /**
-                     * Important:  Doing this sleep(10) is to make sure
-                     * 1. this event is processed by vs code first
-                     * 2. editor.selection.active has been successfully updated by VS Code
-                     * Then this event can be processed by our code.
-                     */
-                    await sleep(CodeWhispererConstants.vsCodeCursorUpdateDelay)
-                    if (InlineCompletion.instance.getIsActive) {
-                        await InlineCompletion.instance.setTypeAheadRecommendations(vscode.window.activeTextEditor, e)
-                    } else {
-                        await KeyStrokeHandler.instance.processKeyStroke(
-                            e,
-                            vscode.window.activeTextEditor,
-                            client,
-                            await getConfigEntry()
-                        )
-                    }
-                }
-            }),
-
-            /**
-             * On recommendation rejection
-             */
-            vscode.window.onDidChangeVisibleTextEditors(async e => {
-                await InlineCompletion.instance.rejectRecommendation(vscode.window.activeTextEditor, false, true)
-            }),
-            vscode.window.onDidChangeActiveTextEditor(async e => {
-                await InlineCompletion.instance.rejectRecommendation(vscode.window.activeTextEditor)
-                if (vscode.window.activeTextEditor) {
-                    CodeWhispererCodeCoverageTracker.getTracker(
-                        vscode.window.activeTextEditor.document.languageId
-                    )?.updateAcceptedTokensCount(vscode.window.activeTextEditor)
-                }
-            }),
-            vscode.window.onDidChangeTextEditorSelection(async e => {
-                if (e.kind === TextEditorSelectionChangeKind.Mouse && vscode.window.activeTextEditor) {
-                    await InlineCompletion.instance.rejectRecommendation(vscode.window.activeTextEditor)
-                }
-            }),
-            /**
-             * Recommendation navigation
-             */
-            Commands.register('aws.codeWhisperer.nextCodeSuggestion', async () => {
-                if (vscode.window.activeTextEditor) {
-                    InlineCompletion.instance.navigateRecommendation(vscode.window.activeTextEditor, true)
-                }
-            }),
-            Commands.register('aws.codeWhisperer.previousCodeSuggestion', async () => {
-                if (vscode.window.activeTextEditor) {
-                    InlineCompletion.instance.navigateRecommendation(vscode.window.activeTextEditor, false)
-                }
-            }),
-            /**
-             * Recommendation acceptance
-             */
-            Commands.register('aws.codeWhisperer.acceptCodeSuggestion', async () => {
-                if (vscode.window.activeTextEditor) {
-                    await InlineCompletion.instance.acceptRecommendation(vscode.window.activeTextEditor)
-                }
-            })
-        )
-
-        InlineCompletion.instance.setCodeWhispererStatusBarOk()
-    }
-
     function setSubscriptionsforCloud9() {
         /**
          * Manual trigger
@@ -567,10 +399,6 @@ export async function shutdown() {
     }
     if (isInlineCompletionEnabled()) {
         await InlineCompletionService.instance.clearInlineCompletionStates(vscode.window.activeTextEditor)
-    } else {
-        if (vscode.window.activeTextEditor) {
-            await InlineCompletion.instance.resetInlineStates(vscode.window.activeTextEditor)
-        }
     }
     CodeWhispererTracker.getTracker().shutdown()
 }

src/codewhisperer/client/codewhisperer.ts

@@ -2,20 +2,17 @@
  * Copyright 2022 Amazon.com, Inc. or its affiliates. All Rights Reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
-import { AWSError, CognitoIdentityCredentials, Service } from 'aws-sdk'
+import { AWSError, Service } from 'aws-sdk'
 import apiConfig = require('./service-2.json')
 import userApiConfig = require('./user-service-2.json')
 import globals from '../../shared/extensionGlobals'
 import * as CodeWhispererClient from './codewhispererclient'
 import * as CodeWhispererUserClient from './codewhispereruserclient'
 import * as CodeWhispererConstants from '../models/constants'
 import { ServiceOptions } from '../../shared/awsClientBuilder'
-import { invalidateAccessToken } from '../util/invalidateToken'
 import { isCloud9 } from '../../shared/extensionUtilities'
 import { CodeWhispererSettings } from '../util/codewhispererSettings'
-import { getCognitoCredentials } from '../util/cognitoIdentity'
 import { PromiseResult } from 'aws-sdk/lib/request'
-import { getLogger } from '../../shared/logger'
 import { Credentials } from 'aws-sdk'
 import { AuthUtil } from '../util/authUtil'
 import { TelemetryHelper } from '../util/telemetryHelper'
@@ -64,54 +61,26 @@ export type CreateCodeScanResponse =
 export type Import = CodeWhispererUserClient.Import
 export type Imports = CodeWhispererUserClient.Imports
 export class DefaultCodeWhispererClient {
-    private credentials?: CognitoIdentityCredentials
-
     private async createSdkClient(): Promise<CodeWhispererClient> {
-        try {
-            if (!this.credentials && !isCloud9()) {
-                this.credentials = await getCognitoCredentials()
-            }
-            if (this.credentials && this.credentials.needsRefresh()) {
-                await new Promise<void>((resolve, reject) =>
-                    this.credentials?.refresh(e => (e ? reject(e) : resolve()))
-                )
-            }
-        } catch (e) {
-            getLogger().debug('Error when getting or refreshing Cognito credentials', e)
-            throw new CognitoCredentialsError('Error when getting or refreshing Cognito credentials')
-        }
-
-        const accessToken = globals.context.globalState.get<string | undefined>(CodeWhispererConstants.accessToken)
         const isOptedOut = CodeWhispererSettings.instance.isOptoutEnabled()
 
         return (await globals.sdkClientBuilder.createAwsService(
             Service,
             {
                 apiConfig: apiConfig,
                 region: CodeWhispererConstants.region,
-                credentials: this.credentials ?? (await AuthUtil.instance.getCredentials()),
+                credentials: await AuthUtil.instance.getCredentials(),
                 endpoint: CodeWhispererConstants.endpoint,
                 onRequestSetup: [
                     req => {
-                        if (!isCloud9() && req.operation !== 'getAccessToken') {
-                            req.on('build', () => {
-                                req.httpRequest.headers['x-amzn-codewhisperer-token'] = accessToken || ''
-                            })
-                            req.on('error', e => {
-                                if (e.code === 'AccessDeniedException') {
-                                    invalidateAccessToken()
-                                }
-                            })
-                        }
                         if (req.operation === 'listRecommendations') {
                             req.on('build', () => {
                                 req.httpRequest.headers['x-amzn-codewhisperer-optout'] = `${isOptedOut}`
                             })
                         }
-
                         // This logic is for backward compatability with legacy SDK v2 behavior for refreshing
                         // credentials. Once the Toolkit adds a file watcher for credentials it won't be needed.
-                        if (isCloud9() && req.operation !== 'getAccessToken') {
+                        if (isCloud9()) {
                             req.on('retry', resp => {
                                 if (
                                     resp.error?.code === 'AccessDeniedException' &&
@@ -161,10 +130,6 @@ export class DefaultCodeWhispererClient {
     }
 
     private isBearerTokenAuth(): boolean {
-        const accessToken = globals.context.globalState.get<string | undefined>(CodeWhispererConstants.accessToken)
-        if (accessToken) {
-            return false
-        }
         return isSsoConnection(AuthUtil.instance.conn)
     }
 
@@ -181,12 +146,6 @@ export class DefaultCodeWhispererClient {
         return (await this.createSdkClient()).listRecommendations(request).promise()
     }
 
-    public async getAccessToken(
-        request: CodeWhispererClient.GetAccessTokenRequest
-    ): Promise<CodeWhispererClient.GetAccessTokenResponse> {
-        return (await this.createSdkClient()).getAccessToken(request).promise()
-    }
-
     public async createUploadUrl(
         request: CreateUploadUrlRequest
     ): Promise<PromiseResult<CreateUploadUrlResponse, AWSError>> {

src/codewhisperer/commands/basicCommands.ts

@@ -120,13 +120,6 @@ export const showLearnMore = Commands.declare('aws.codeWhisperer.learnMore', ()
     vscode.env.openExternal(vscode.Uri.parse(CodeWhispererConstants.learnMoreUriGeneral))
 })
 
-export const showAccessTokenErrorLearnMore = Commands.declare(
-    'aws.codeWhisperer.accessTokenErrorLearnMore',
-    () => async () => {
-        vscode.env.openExternal(vscode.Uri.parse(CodeWhispererConstants.accessTokenMigrationLearnMoreUri))
-    }
-)
-
 // TODO: Use a different URI
 export const showFreeTierLimit = Commands.declare('aws.codeWhisperer.freeTierLimit', () => async () => {
     vscode.env.openExternal(vscode.Uri.parse(CodeWhispererConstants.learnMoreUri))