Merge master into feature/ui-e2e-tests

Author: aws-toolkit-automation

packages/amazonq/test/e2e/index.ts

@@ -4,10 +4,10 @@
  */
 
 import { runTests } from 'aws-core-vscode/test'
-import { VSCODE_EXTENSION_ID } from 'aws-core-vscode/utils'
+import { VSCODE_EXTENSION_ID_CONSTANTS } from 'aws-core-vscode/utils'
 
 export function run(): Promise<void> {
-    return runTests(process.env.TEST_DIR ?? 'test/e2e', VSCODE_EXTENSION_ID.amazonq, [
+    return runTests(process.env.TEST_DIR ?? 'test/e2e', VSCODE_EXTENSION_ID_CONSTANTS.amazonq, [
         '../../core/dist/src/testInteg/globalSetup.test.ts',
     ])
 }

packages/amazonq/test/unit/index.ts

@@ -4,10 +4,10 @@
  */
 
 import { runTests } from 'aws-core-vscode/test'
-import { VSCODE_EXTENSION_ID } from 'aws-core-vscode/utils'
+import { VSCODE_EXTENSION_ID_CONSTANTS } from 'aws-core-vscode/utils'
 
 export function run(): Promise<void> {
-    return runTests(process.env.TEST_DIR ?? ['test/unit'], VSCODE_EXTENSION_ID.amazonq, [
+    return runTests(process.env.TEST_DIR ?? ['test/unit'], VSCODE_EXTENSION_ID_CONSTANTS.amazonq, [
         '../../core/dist/src/test/globalSetup.test.ts',
     ])
 }

packages/amazonq/test/web/testRunner.ts

@@ -7,7 +7,7 @@
  * The following was influenced by this guide: https://code.visualstudio.com/api/extension-guides/web-extensions
  */
 
-import { VSCODE_EXTENSION_ID } from 'aws-core-vscode/utils'
+import { VSCODE_EXTENSION_ID_CONSTANTS } from 'aws-core-vscode/utils'
 import 'mocha' // Imports mocha for the browser, defining the `mocha` global.
 import * as vscode from 'vscode'
 
@@ -47,12 +47,12 @@ function gatherTestFiles() {
  * So this function ensures the extension has fully activated.
  */
 async function activateExtension() {
-    const extId = VSCODE_EXTENSION_ID.amazonq
+    const extId = VSCODE_EXTENSION_ID_CONSTANTS.amazonq
     const ext = vscode.extensions.getExtension(extId)
     if (!ext) {
         throw new Error(`Extension '${extId}' not found, can't activate it to run tests.`)
     }
-    await vscode.extensions.getExtension(VSCODE_EXTENSION_ID.amazonq)?.activate()
+    await vscode.extensions.getExtension(VSCODE_EXTENSION_ID_CONSTANTS.amazonq)?.activate()
 }
 
 function runMochaTests(resolve: (value: void | PromiseLike<void>) => void, reject: (reason?: any) => void) {

packages/core/scripts/test/launchTestUtilities.ts

@@ -8,7 +8,7 @@ import packageJson from '../../package.json'
 import { downloadAndUnzipVSCode, resolveCliArgsFromVSCodeExecutablePath } from '@vscode/test-electron'
 import { join, resolve } from 'path'
 import { runTests } from '@vscode/test-electron'
-import { VSCODE_EXTENSION_ID } from '../../src/shared/extensions'
+import { VSCODE_EXTENSION_ID_CONSTANTS } from '../../src/shared/extensionIds'
 import { TestOptions } from '@vscode/test-electron/out/runTest'
 
 const envvarVscodeTestVersion = 'VSCODE_TEST_VERSION'
@@ -79,14 +79,14 @@ async function getVSCodeCliArgs(params: {
     if (params.suite === 'integration' || params.suite === 'e2e') {
         disableExtensionsArgs = await getCliArgsToDisableExtensions(params.vsCodeExecutablePath, {
             except: [
-                VSCODE_EXTENSION_ID.python,
-                VSCODE_EXTENSION_ID.yaml,
-                VSCODE_EXTENSION_ID.jupyter,
-                VSCODE_EXTENSION_ID.go,
-                VSCODE_EXTENSION_ID.java,
-                VSCODE_EXTENSION_ID.javadebug,
-                VSCODE_EXTENSION_ID.git,
-                VSCODE_EXTENSION_ID.remotessh,
+                VSCODE_EXTENSION_ID_CONSTANTS.python,
+                VSCODE_EXTENSION_ID_CONSTANTS.yaml,
+                VSCODE_EXTENSION_ID_CONSTANTS.jupyter,
+                VSCODE_EXTENSION_ID_CONSTANTS.go,
+                VSCODE_EXTENSION_ID_CONSTANTS.java,
+                VSCODE_EXTENSION_ID_CONSTANTS.javadebug,
+                VSCODE_EXTENSION_ID_CONSTANTS.git,
+                VSCODE_EXTENSION_ID_CONSTANTS.remotessh.id,
             ],
         })
         disableWorkspaceTrustArg = [disableWorkspaceTrust]
@@ -160,11 +160,11 @@ async function setupVSCodeTestInstance(suite: SuiteName): Promise<string> {
 
     // Only certain test suites require specific vscode extensions to be installed
     if (suite === 'e2e' || suite === 'integration') {
-        await installVSCodeExtension(vsCodeExecutablePath, VSCODE_EXTENSION_ID.python)
-        await installVSCodeExtension(vsCodeExecutablePath, VSCODE_EXTENSION_ID.yaml)
-        await installVSCodeExtension(vsCodeExecutablePath, VSCODE_EXTENSION_ID.go)
-        await installVSCodeExtension(vsCodeExecutablePath, VSCODE_EXTENSION_ID.java)
-        await installVSCodeExtension(vsCodeExecutablePath, VSCODE_EXTENSION_ID.javadebug)
+        await installVSCodeExtension(vsCodeExecutablePath, VSCODE_EXTENSION_ID_CONSTANTS.python)
+        await installVSCodeExtension(vsCodeExecutablePath, VSCODE_EXTENSION_ID_CONSTANTS.yaml)
+        await installVSCodeExtension(vsCodeExecutablePath, VSCODE_EXTENSION_ID_CONSTANTS.go)
+        await installVSCodeExtension(vsCodeExecutablePath, VSCODE_EXTENSION_ID_CONSTANTS.java)
+        await installVSCodeExtension(vsCodeExecutablePath, VSCODE_EXTENSION_ID_CONSTANTS.javadebug)
     }
 
     console.log('VS Code Test instance has been set up')

packages/core/src/awsService/sagemaker/detached-server/server.ts

@@ -17,6 +17,16 @@ import { execFile } from 'child_process'
 
 const pollInterval = 30 * 60 * 100 // 30 minutes
 
+/**
+ * Generic IDE process patterns for detection across all VS Code forks
+ * Supports: VS Code, Cursor, Kiro, Windsurf, and other forks
+ */
+const IDE_PROCESS_PATTERNS = {
+    windows: /Code\.exe|Cursor\.exe|Kiro\.exe|Windsurf\.exe/i,
+    darwin: /(Visual Studio Code( - Insiders)?|Cursor|Kiro|Windsurf)\.app\/Contents\/MacOS\/Electron/,
+    linux: /^(code(-insiders)?|cursor|kiro|windsurf|electron)$/i,
+}
+
 const server = http.createServer((req: IncomingMessage, res: ServerResponse) => {
     const parsedUrl = url.parse(req.url || '', true)
 
@@ -62,12 +72,13 @@ function checkVSCodeWindows(): Promise<boolean> {
         const platform = os.platform()
 
         if (platform === 'win32') {
-            execFile('tasklist', ['/FI', 'IMAGENAME eq Code.exe'], (err, stdout) => {
+            // Check for any VS Code fork process
+            execFile('tasklist', [], (err, stdout) => {
                 if (err) {
                     resolve(false)
                     return
                 }
-                resolve(/Code\.exe/i.test(stdout))
+                resolve(IDE_PROCESS_PATTERNS.windows.test(stdout))
             })
         } else if (platform === 'darwin') {
             execFile('ps', ['aux'], (err, stdout) => {
@@ -76,9 +87,7 @@ function checkVSCodeWindows(): Promise<boolean> {
                     return
                 }
 
-                const found = stdout
-                    .split('\n')
-                    .some((line) => /Visual Studio Code( - Insiders)?\.app\/Contents\/MacOS\/Electron/.test(line))
+                const found = stdout.split('\n').some((line) => IDE_PROCESS_PATTERNS.darwin.test(line))
                 resolve(found)
             })
         } else {
@@ -88,7 +97,7 @@ function checkVSCodeWindows(): Promise<boolean> {
                     return
                 }
 
-                const found = stdout.split('\n').some((line) => /^(code(-insiders)?|electron)$/i.test(line.trim()))
+                const found = stdout.split('\n').some((line) => IDE_PROCESS_PATTERNS.linux.test(line.trim()))
                 resolve(found)
             })
         }
@@ -99,7 +108,7 @@ async function monitorVSCodeAndExit() {
     while (true) {
         const found = await checkVSCodeWindows()
         if (!found) {
-            console.log('No VSCode windows found. Shutting down detached server.')
+            console.log('No IDE windows found. Shutting down detached server.')
             process.exit(0)
         }
         await new Promise((r) => setTimeout(r, pollInterval))

packages/core/src/shared/extensionIds.ts

@@ -0,0 +1,37 @@
+/*!
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+// eslint-disable-next-line @typescript-eslint/naming-convention
+export const VSCODE_REMOTE_SSH_EXTENSION = {
+    cursor: {
+        id: 'anysphere.remote-ssh',
+        minVersion: '1.0.2',
+    },
+    vscode: {
+        id: 'ms-vscode-remote.remote-ssh',
+        minVersion: '0.74.0',
+    },
+} as const
+
+/**
+ * Extension IDs that don't require runtime vscode access.
+ * Safe to import in test environments.
+ */
+// eslint-disable-next-line @typescript-eslint/naming-convention
+export const VSCODE_EXTENSION_ID_CONSTANTS = {
+    awstoolkit: 'amazonwebservices.aws-toolkit-vscode',
+    amazonq: 'amazonwebservices.amazon-q-vscode',
+    python: 'ms-python.python',
+    // python depends on jupyter plugin
+    jupyter: 'ms-toolsai.jupyter',
+    yaml: 'redhat.vscode-yaml',
+    go: 'golang.go',
+    java: 'redhat.java',
+    javadebug: 'vscjava.vscode-java-debug',
+    dotnet: 'ms-dotnettools.csdevkit',
+    git: 'vscode.git',
+    // default to VSCode in test environment
+    remotessh: VSCODE_REMOTE_SSH_EXTENSION.vscode,
+} as const

packages/core/src/shared/extensions.ts

@@ -10,27 +10,37 @@ import { TelemetryService } from './telemetry/telemetryService'
 import { CredentialsStore } from '../auth/credentials/store'
 import { SamCliContext } from './sam/cli/samCliContext'
 import { UriHandler } from './vscode/uriHandler'
+import { VSCODE_EXTENSION_ID_CONSTANTS, VSCODE_REMOTE_SSH_EXTENSION } from './extensionIds'
 
+// Determine the remote SSH extension based on the editor
+const getRemoteSshExtension = () => {
+    const appName = vscode?.env?.appName?.toLowerCase()
+    if (!appName) {
+        return VSCODE_REMOTE_SSH_EXTENSION.vscode
+    }
+
+    // Check each IDE key in the extension map
+    for (const key of Object.keys(VSCODE_REMOTE_SSH_EXTENSION)) {
+        if (appName.includes(key)) {
+            return VSCODE_REMOTE_SSH_EXTENSION[key as keyof typeof VSCODE_REMOTE_SSH_EXTENSION]
+        }
+    }
+
+    return VSCODE_REMOTE_SSH_EXTENSION.vscode
+}
+
+// For actual use in IDE, not test environment
 // eslint-disable-next-line @typescript-eslint/naming-convention
 export const VSCODE_EXTENSION_ID = {
-    awstoolkit: 'amazonwebservices.aws-toolkit-vscode',
-    amazonq: 'amazonwebservices.amazon-q-vscode',
-    python: 'ms-python.python',
-    // python depends on jupyter plugin
-    jupyter: 'ms-toolsai.jupyter',
-    yaml: 'redhat.vscode-yaml',
-    go: 'golang.go',
-    java: 'redhat.java',
-    javadebug: 'vscjava.vscode-java-debug',
-    dotnet: 'ms-dotnettools.csdevkit',
-    git: 'vscode.git',
-    remotessh: 'ms-vscode-remote.remote-ssh',
-} as const
-
-export const vscodeExtensionMinVersion = {
-    remotessh: '0.74.0',
+    ...VSCODE_EXTENSION_ID_CONSTANTS,
+    get remotessh(): { readonly id: string; readonly minVersion: string } {
+        return getRemoteSshExtension()
+    },
 }
 
+// Re-export for backward compatibility
+export { VSCODE_REMOTE_SSH_EXTENSION }
+
 /** @deprecated Use `extensionGlobals.ts:globals` instead. */
 export interface ExtContext {
     extensionContext: vscode.ExtensionContext

packages/core/src/shared/remoteSession.ts

@@ -7,11 +7,12 @@ import * as vscode from 'vscode'
 import * as nls from 'vscode-nls'
 const localize = nls.loadMessageBundle()
 
+import { getIdeInfo } from './vscode/env'
 import { Settings } from '../shared/settings'
 import { showConfirmationMessage, showMessageWithCancel } from './utilities/messages'
 import { CancellationError, Timeout } from './utilities/timeoutUtils'
 import { isExtensionInstalled, showInstallExtensionMsg } from './utilities/vsCodeUtils'
-import { VSCODE_EXTENSION_ID, vscodeExtensionMinVersion } from './extensions'
+import { VSCODE_EXTENSION_ID } from './extensions'
 import { Err, Result } from '../shared/utilities/result'
 import { ToolkitError, UnknownError } from './errors'
 import { getLogger } from './logger/logger'
@@ -31,7 +32,7 @@ export enum RemoteSessionError {
 }
 
 export interface MissingTool {
-    readonly name: 'code' | 'ssm' | 'ssh'
+    readonly name: string
     readonly reason?: string
 }
 
@@ -108,19 +109,19 @@ export async function ensureDependencies(): Promise<Result<DependencyPaths, Canc
 }
 
 export async function ensureRemoteSshInstalled(): Promise<void> {
-    if (!isExtensionInstalled(VSCODE_EXTENSION_ID.remotessh, vscodeExtensionMinVersion.remotessh)) {
+    if (!isExtensionInstalled(VSCODE_EXTENSION_ID.remotessh.id, VSCODE_EXTENSION_ID.remotessh.minVersion)) {
         showInstallExtensionMsg(
-            VSCODE_EXTENSION_ID.remotessh,
+            VSCODE_EXTENSION_ID.remotessh.id,
             'Remote SSH',
             'Connecting to Dev Environment',
-            vscodeExtensionMinVersion.remotessh
+            VSCODE_EXTENSION_ID.remotessh.minVersion
         )
 
-        if (isExtensionInstalled(VSCODE_EXTENSION_ID.remotessh)) {
+        if (isExtensionInstalled(VSCODE_EXTENSION_ID.remotessh.id)) {
             throw new ToolkitError('Remote SSH extension version is too low', {
                 cancelled: true,
                 code: RemoteSessionError.ExtensionVersionTooLow,
-                details: { expected: vscodeExtensionMinVersion.remotessh },
+                details: { expected: VSCODE_EXTENSION_ID.remotessh.minVersion },
             })
         } else {
             throw new ToolkitError('Remote SSH extension not installed', {
@@ -146,8 +147,11 @@ async function ensureSsmCli() {
 export async function ensureTools() {
     const [vsc, ssh, ssm] = await Promise.all([getVscodeCliPath(), findSshPath(), ensureSsmCli()])
 
+    const ideInfo = getIdeInfo()
+    const cliName = ideInfo.cliName
+
     const missing: MissingTool[] = []
-    pushIf(missing, vsc === undefined, { name: 'code' })
+    pushIf(missing, vsc === undefined, { name: cliName })
     pushIf(missing, ssh === undefined, { name: 'ssh' })
 
     if (ssm.isErr()) {

packages/core/src/shared/utilities/index.ts

@@ -5,6 +5,7 @@
 
 export { isExtensionInstalled, isExtensionActive } from './vsCodeUtils'
 export { VSCODE_EXTENSION_ID } from '../extensions'
+export { VSCODE_EXTENSION_ID_CONSTANTS } from '../extensionIds'
 export * from './functionUtils'
 export * as messageUtils from './messages'
 export * as CommentUtils from './commentUtils'

packages/core/src/shared/utilities/pathFind.ts

@@ -12,6 +12,7 @@ import { Settings } from '../settings'
 import { getLogger } from '../logger/logger'
 import { mergeResolvedShellPath } from '../env/resolveEnv'
 import { matchesPattern } from './textUtilities'
+import { getIdeInfo } from '../vscode/env'
 
 /** Full path to VSCode CLI. */
 let vscPath: string
@@ -52,7 +53,7 @@ export async function tryRun(
 }
 
 /**
- * Gets the fullpath to `code` (VSCode CLI), or falls back to "code" (not
+ * Gets the fullpath to the IDE CLI (code, cursor, kiro, windsurf, etc.), or falls back to the CLI name (not
  * absolute) if it works.
  *
  * @see https://github.com/microsoft/vscode-test/blob/4bdccd4c386813a8158b0f9b96f31cbbecbb3374/lib/util.ts#L133
@@ -62,27 +63,30 @@ export async function getVscodeCliPath(): Promise<string | undefined> {
         return vscPath
     }
 
+    const ideInfo = getIdeInfo()
+    const cliName = ideInfo.cliName || 'code'
+
     const vscExe = process.argv0
     // https://github.com/microsoft/vscode-test/blob/4bdccd4c386813a8158b0f9b96f31cbbecbb3374/lib/util.ts#L133
     const vscs = [
         // Special case for flatpak (steamdeck). #V896741845
         // https://github.com/flathub/com.visualstudio.code/blob/master/code.sh
-        '/app/bin/code',
+        `/app/bin/${cliName}`,
         // Note: macOS does not have a separate "code-insiders" binary.
-        path.resolve(`${vscode.env.appRoot}/bin/code`), // macOS
-        path.resolve(`${vscode.env.appRoot}/../../bin/code`), // Windows
-        path.resolve(`${vscode.env.appRoot}/../../bin/code-insiders`), // Windows
+        path.resolve(`${vscode.env.appRoot}/bin/${cliName}`), // macOS
+        path.resolve(`${vscode.env.appRoot}/../../bin/${cliName}`), // Windows
+        path.resolve(`${vscode.env.appRoot}/../../bin/${cliName}-insiders`), // Windows
         // Linux example "appRoot": vscode-linux-x64-1.42.0/VSCode-linux-x64/resources/app
-        path.resolve(`${vscode.env.appRoot}/code`),
-        path.resolve(vscExe, '../bin/code-insiders'),
-        path.resolve(vscExe, '../bin/code'),
-        path.resolve(vscExe, '../../bin/code-insiders'),
-        path.resolve(vscExe, '../../bin/code'),
-        '/usr/bin/code',
-        'code', // $PATH
+        path.resolve(`${vscode.env.appRoot}/${cliName}`),
+        path.resolve(vscExe, `../bin/${cliName}-insiders`),
+        path.resolve(vscExe, `../bin/${cliName}`),
+        path.resolve(vscExe, `../../bin/${cliName}-insiders`),
+        path.resolve(vscExe, `../../bin/${cliName}`),
+        `/usr/bin/${cliName}`,
+        cliName, // $PATH
     ]
     for (const vsc of vscs) {
-        if (!vsc || (vsc !== 'code' && !(await fs.exists(vsc)))) {
+        if (!vsc || (vsc !== cliName && !(await fs.exists(vsc)))) {
             continue
         }
         if (await tryRun(vsc, ['--version'])) {