Merge master into feature/smus

Author: aws-toolkit-automation

packages/core/src/lambda/remoteDebugging/ldkController.ts

@@ -280,33 +280,86 @@ function isVscodeGlob(pattern: string): boolean {
     return /[*?[\]{}]/.test(pattern)
 }
 
+/**
+ * Extract temp directory patterns from source map files
+ * @param mapFiles Array of source map file paths
+ * @returns Set of temp directory patterns found in source maps
+ */
+async function extractTempPatternsFromSourceMaps(mapFiles: string[]): Promise<Set<string>> {
+    const tempPatterns = new Set<string>()
+
+    for (const mapFile of mapFiles) {
+        try {
+            const content = await fs.readFileText(mapFile)
+            const sourceMap = JSON.parse(content)
+
+            if (sourceMap.sources && Array.isArray(sourceMap.sources)) {
+                for (const source of sourceMap.sources) {
+                    // SAM uses Python's tempfile.mkdtemp() to create tmp dir which we want to detect
+                    // tempfile.mkdtemp() uses lowercase letters, digits, and underscores
+                    // The pattern is: tmp followed by 8 characters from [a-z0-9_]
+                    // see https://github.com/python/cpython/blob/20a677d75a95fa63be904f7ca4f8cb268aec95c1/Lib/tempfile.py#L132-L140
+                    const tempMatch = source.match(/\btmp[a-z0-9_]{8}\b/)
+                    if (tempMatch) {
+                        tempPatterns.add(tempMatch[0])
+                        getLogger().debug(`Found temp pattern in source map: ${tempMatch[0]}`)
+                    }
+                }
+            }
+        } catch (error) {
+            getLogger().debug(`Failed to read or parse source map ${mapFile}: ${error}`)
+        }
+    }
+
+    return tempPatterns
+}
+
 /**
  * Helper function to validate source map files exist for given outFiles patterns
+ * @returns Object with validation result and temp patterns found in source maps
  */
-async function validateSourceMapFiles(outFiles: string[]): Promise<boolean> {
+export async function validateSourceMapFiles(
+    outFiles: string[]
+): Promise<{ isValid: boolean; tempPatterns: Set<string> }> {
+    getLogger().debug(`validating outFiles ${outFiles}`)
     const allAreGlobs = outFiles.every((pattern) => isVscodeGlob(pattern))
     if (!allAreGlobs) {
-        return false
+        return { isValid: false, tempPatterns: new Set() }
     }
 
     try {
         let jsfileCount = 0
         let mapfileCount = 0
-        const jsFiles = await glob(outFiles, { ignore: 'node_modules/**' })
+        const mapFiles: string[] = []
+
+        // Convert Windows paths to use forward slashes for glob
+        const normalizedOutFiles = outFiles.map((pattern) => {
+            // Replace backslashes with forward slashes for glob compatibility
+            return pattern.replaceAll(/\\/g, '/')
+        })
+        getLogger().debug(`normalizedOutFiles ${normalizedOutFiles}`)
+        const jsFiles = await glob(normalizedOutFiles, { ignore: 'node_modules/**' })
 
         for (const file of jsFiles) {
             if (file.includes('js')) {
                 jsfileCount += 1
             }
             if (file.includes('.map')) {
                 mapfileCount += 1
+                mapFiles.push(file)
             }
         }
 
-        return jsfileCount === 0 || mapfileCount === 0 ? false : true
+        // Extract temp patterns from source map files
+        const tempPatterns = await extractTempPatternsFromSourceMaps(mapFiles)
+
+        return {
+            isValid: jsfileCount > 0 && mapfileCount > 0,
+            tempPatterns,
+        }
     } catch (error) {
         getLogger().warn(`Error validating source map files: ${error}`)
-        return false
+        return { isValid: false, tempPatterns: new Set() }
     }
 }
 
@@ -412,19 +465,26 @@ async function getVscodeDebugConfig(
                 debugConfig.outFiles = processOutFiles(debugConfig.outFiles, debugConfig.localRoot)
 
                 // Use glob to search if there are any matching js file or source map file
-                const hasSourceMaps = await validateSourceMapFiles(debugConfig.outFiles)
+                const sourceMapValidation = await validateSourceMapFiles(debugConfig.outFiles)
 
-                if (hasSourceMaps) {
-                    // support mapping common sam cli location
-                    additionalParams['sourceMapPathOverrides'] = {
+                if (sourceMapValidation.isValid) {
+                    // Start with basic source map overrides
+                    const sourceMapOverrides: Record<string, string> = {
                         ...additionalParams['sourceMapPathOverrides'],
-                        '?:*/T/?:*/*': path.join(debugConfig.localRoot, '*'),
                     }
+
+                    // Add specific temp directory patterns found in source maps
+                    for (const tempPattern of sourceMapValidation.tempPatterns) {
+                        sourceMapOverrides[`?:*/${tempPattern}/*`] = path.join(debugConfig.localRoot, '*')
+                        getLogger().info(`Added source map override for temp pattern: ${tempPattern}`)
+                    }
+
+                    additionalParams['sourceMapPathOverrides'] = sourceMapOverrides
                     debugConfig.localRoot = debugConfig.outFiles[0].split('*')[0]
                 } else {
                     debugConfig.sourceMap = false
                     debugConfig.outFiles = undefined
-                    await showMessage(
+                    void showMessage(
                         'warn',
                         localize(
                             'AWS.lambda.remoteDebug.outFileNotFound',

packages/core/src/lambda/vue/remoteInvoke/invokeLambda.ts

@@ -283,17 +283,28 @@ export class RemoteInvokeWebview extends VueWebview {
         this.channel.appendLine('Loading response...')
         await telemetry.lambda_invokeRemote.run(async (span) => {
             try {
-                const funcResponse = remoteDebugEnabled
-                    ? await this.clientDebug.invoke(this.data.FunctionArn, input, qualifier)
-                    : await this.client.invoke(this.data.FunctionArn, input, qualifier)
+                let funcResponse
+                const snapStartDisabled =
+                    !this.data.LambdaFunctionNode?.configuration.SnapStart &&
+                    this.data.LambdaFunctionNode?.configuration.State !== 'Active'
+                if (remoteDebugEnabled) {
+                    funcResponse = await this.clientDebug.invoke(this.data.FunctionArn, input, qualifier)
+                } else if (snapStartDisabled) {
+                    funcResponse = await this.client.invoke(this.data.FunctionArn, input, qualifier, 'None')
+                } else {
+                    funcResponse = await this.client.invoke(this.data.FunctionArn, input, qualifier, 'Tail')
+                }
+
                 const logs = funcResponse.LogResult ? decodeBase64(funcResponse.LogResult) : ''
                 const decodedPayload = funcResponse.Payload ? new TextDecoder().decode(funcResponse.Payload) : ''
                 const payload = decodedPayload || JSON.stringify({})
 
                 this.channel.appendLine(`Invocation result for ${this.data.FunctionArn}`)
-                this.channel.appendLine('Logs:')
-                this.channel.appendLine(logs)
-                this.channel.appendLine('')
+                if (!snapStartDisabled) {
+                    this.channel.appendLine('Logs:')
+                    this.channel.appendLine(logs)
+                    this.channel.appendLine('')
+                }
                 this.channel.appendLine('Payload:')
                 this.channel.appendLine(String(payload))
                 this.channel.appendLine('')

packages/core/src/shared/clients/lambdaClient.ts

@@ -66,13 +66,18 @@ export class DefaultLambdaClient {
         )
     }
 
-    public async invoke(name: string, payload?: BlobPayloadInputTypes, version?: string): Promise<InvocationResponse> {
+    public async invoke(
+        name: string,
+        payload?: BlobPayloadInputTypes,
+        version?: string,
+        logtype: 'Tail' | 'None' = 'Tail'
+    ): Promise<InvocationResponse> {
         const sdkClient = await this.createSdkClient()
 
         const response = await sdkClient.send(
             new InvokeCommand({
                 FunctionName: name,
-                LogType: 'Tail',
+                LogType: logtype,
                 Payload: payload,
                 Qualifier: version,
             })

packages/core/src/test/lambda/remoteDebugging/ldkController.test.ts

@@ -12,6 +12,7 @@ import {
     activateRemoteDebugging,
     revertExistingConfig,
     tryAutoDetectOutFile,
+    validateSourceMapFiles,
 } from '../../../lambda/remoteDebugging/ldkController'
 import { getLambdaSnapshot, type DebugConfig } from '../../../lambda/remoteDebugging/lambdaDebugger'
 import { LdkClient } from '../../../lambda/remoteDebugging/ldkClient'
@@ -32,6 +33,7 @@ import {
 import { getRemoteDebugLayer } from '../../../lambda/remoteDebugging/remoteLambdaDebugger'
 import { fs } from '../../../shared/fs/fs'
 import * as detectCdkProjects from '../../../awsService/cdk/explorer/detectCdkProjects'
+import * as glob from 'glob'
 
 describe('RemoteDebugController', () => {
     let sandbox: sinon.SinonSandbox
@@ -648,6 +650,94 @@ describe('tryAutoDetectOutFile', () => {
     })
 })
 
+describe('Source Map Pattern Extraction', () => {
+    let sandbox: sinon.SinonSandbox
+
+    beforeEach(() => {
+        sandbox = sinon.createSandbox()
+    })
+
+    afterEach(() => {
+        sandbox.restore()
+    })
+
+    it('should extract temp patterns from source map files', async () => {
+        assert(vscode.workspace.workspaceFolders?.[0]?.uri, 'Test env should have a workdir')
+        const testPath = vscode.Uri.joinPath(vscode.workspace.workspaceFolders?.[0]?.uri, 'remote-debug-ts-app').fsPath
+
+        // Call validateSourceMapFiles which will extract temp patterns
+        const result = await validateSourceMapFiles([`${testPath}/*`])
+
+        assert(result.isValid, 'Should find valid source map files')
+        assert(result.tempPatterns.has('tmp5bmwuffn'), 'Should extract temp pattern tmp5bmwuffn from source map')
+    })
+
+    it('should handle multiple temp patterns in source maps', async () => {
+        // Create a mock source map with multiple temp patterns
+        // Updated to use lowercase and underscore patterns matching Python's tempfile.mkdtemp()
+        const mockSourceMap = {
+            version: 3,
+            file: 'index.js',
+            sources: [
+                '../../../../../../tmpa1b2c3d4/index.ts',
+                '../../../../../../tmpx9y8_7w6/utils.ts',
+                '../../../../../../tmp_test123/helper.ts',
+                '/var/task/regular-path.ts', // This should not match
+            ],
+            mappings: 'AAAA',
+        }
+
+        // Mock fs.readFileText to return our mock source map
+        sandbox.stub(fs, 'readFileText').resolves(JSON.stringify(mockSourceMap))
+
+        // Call extractTempPatternsFromSourceMaps directly (we need to export it first)
+        // For now, we'll test through validateSourceMapFiles
+
+        sandbox.stub(glob, 'glob').resolves(['/test/path/index.js', '/test/path/index.js.map'])
+
+        const result = await validateSourceMapFiles(['/test/path/*'])
+
+        assert(result.isValid, 'Should be valid')
+        assert(result.tempPatterns.has('tmpa1b2c3d4'), 'Should extract first temp pattern')
+        assert(result.tempPatterns.has('tmpx9y8_7w6'), 'Should extract second temp pattern')
+        assert(result.tempPatterns.has('tmp_test123'), 'Should extract third temp pattern')
+        assert.strictEqual(result.tempPatterns.size, 3, 'Should have exactly 3 temp patterns')
+    })
+
+    it('should handle source maps without temp patterns', async () => {
+        // Create a mock source map without temp patterns
+        const mockSourceMap = {
+            version: 3,
+            file: 'index.js',
+            sources: ['./index.ts', '../utils/helper.ts'],
+            mappings: 'AAAA',
+        }
+
+        // Mock fs.readFileText
+        sandbox.stub(fs, 'readFileText').resolves(JSON.stringify(mockSourceMap))
+
+        // Mock glob
+        sandbox.stub(glob, 'glob').resolves(['/test/path/index.js', '/test/path/index.js.map'])
+
+        const result = await validateSourceMapFiles(['/test/path/*'])
+
+        assert(result.isValid, 'Should be valid even without temp patterns')
+        assert.strictEqual(result.tempPatterns.size, 0, 'Should have no temp patterns')
+    })
+
+    it('should handle malformed source map files gracefully', async () => {
+        // Mock fs.readFileText to return invalid JSON
+        sandbox.stub(fs, 'readFileText').resolves('{ invalid json }')
+
+        sandbox.stub(glob, 'glob').resolves(['/test/path/index.js', '/test/path/index.js.map'])
+
+        const result = await validateSourceMapFiles(['/test/path/*'])
+
+        assert(result.isValid, 'Should still be valid despite malformed source map')
+        assert.strictEqual(result.tempPatterns.size, 0, 'Should have no temp patterns when parsing fails')
+    })
+})
+
 describe('Module Functions', () => {
     let sandbox: sinon.SinonSandbox
     let mockGlobalState: any

packages/core/src/test/lambda/vue/remoteInvoke/invokeLambda.test.ts

@@ -42,6 +42,11 @@ describe('RemoteInvokeWebview', () => {
             FunctionArn: 'arn:aws:lambda:us-west-2:123456789012:function:testFunction',
             FunctionRegion: 'us-west-2',
             InputSamples: [],
+            LambdaFunctionNode: {
+                configuration: {
+                    State: 'Active',
+                },
+            } as LambdaFunctionNode,
         } as InitialData
 
         remoteInvokeWebview = new RemoteInvokeWebview(outputChannel, client, client, data)
@@ -53,6 +58,11 @@ describe('RemoteInvokeWebview', () => {
                 FunctionArn: 'arn:aws:lambda:us-west-2:123456789012:function:testFunction',
                 FunctionRegion: 'us-west-2',
                 InputSamples: [],
+                LambdaFunctionNode: {
+                    configuration: {
+                        State: 'Active',
+                    },
+                } as LambdaFunctionNode,
             }
             const result = remoteInvokeWebview.init()
             assert.deepEqual(result, mockData)
@@ -74,7 +84,7 @@ describe('RemoteInvokeWebview', () => {
 
             await remoteInvokeWebview.invokeLambda(input)
             assert(client.invoke.calledOnce)
-            assert(client.invoke.calledWith(data.FunctionArn, input))
+            assert(client.invoke.calledWith(data.FunctionArn, input, sinon.match.any, 'Tail'))
             assert.deepStrictEqual(appendedLines, [
                 'Loading response...',
                 'Invocation result for arn:aws:lambda:us-west-2:123456789012:function:testFunction',