support CDK outfile auto detection

Author: roger-zhangg

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

@@ -30,6 +30,8 @@ export interface DebugConfig {
     lambdaTimeout?: number
     layerArn?: string
     handlerFile?: string
+    samProjectLogicalId?: string // SAM project logical ID for auto-detecting outFiles
+    samProjectRoot?: vscode.Uri // SAM project root for auto-detecting outFiles
     isLambdaRemote: boolean // false if LocalStack connection
 }
 

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

@@ -20,6 +20,8 @@ import { Commands } from '../../shared/vscode/commands2'
 import { getLambdaSnapshot, persistLambdaSnapshot, type LambdaDebugger, type DebugConfig } from './lambdaDebugger'
 import { RemoteLambdaDebugger } from './remoteLambdaDebugger'
 import { LocalStackLambdaDebugger } from './localStackLambdaDebugger'
+import { fs } from '../../shared/fs/fs'
+import { detectCdkProjects } from '../../awsService/cdk/explorer/detectCdkProjects'
 
 const localize = nls.loadMessageBundle()
 const logger = getLogger()
@@ -165,6 +167,108 @@ export async function activateRemoteDebugging(): Promise<void> {
     }
 }
 
+/**
+ * Try to auto-detect outFile for TypeScript debugging (SAM or CDK)
+ * @param debugConfig Debug configuration
+ * @param functionConfig Lambda function configuration
+ * @returns The auto-detected outFile path or undefined
+ */
+export async function tryAutoDetectOutFile(
+    debugConfig: DebugConfig,
+    functionConfig: Lambda.FunctionConfiguration
+): Promise<string | undefined> {
+    // Only works for TypeScript files
+    if (
+        !debugConfig.handlerFile ||
+        (!debugConfig.handlerFile.endsWith('.ts') && !debugConfig.handlerFile.endsWith('.tsx'))
+    ) {
+        return undefined
+    }
+
+    // Try SAM detection first using the provided parameters
+    if (debugConfig.samProjectLogicalId && debugConfig.samProjectRoot) {
+        // if proj root is ..../sam-proj/
+        // build dir will be ..../sam-proj/.aws-sam/build/{LogicalID}/
+        const samBuildPath = vscode.Uri.joinPath(
+            debugConfig.samProjectRoot,
+            '.aws-sam',
+            'build',
+            debugConfig.samProjectLogicalId
+        )
+
+        if (await fs.exists(samBuildPath)) {
+            getLogger().info(`SAM outFile auto-detected: ${samBuildPath.fsPath}`)
+            return samBuildPath.fsPath
+        }
+    }
+
+    // If SAM detection didn't work, try CDK detection using the function name
+    if (!functionConfig.FunctionName) {
+        return undefined
+    }
+
+    try {
+        // Find which workspace contains the handler file
+        const workspaceFolder = vscode.workspace.getWorkspaceFolder(vscode.Uri.file(debugConfig.handlerFile))
+        if (!workspaceFolder) {
+            return undefined
+        }
+
+        // Detect CDK projects in the workspace
+        const cdkProjects = await detectCdkProjects([workspaceFolder])
+
+        for (const project of cdkProjects) {
+            // Check if CDK project contains the handler file
+            const cdkProjectDir = vscode.Uri.joinPath(project.cdkJsonUri, '..')
+            if (!debugConfig.handlerFile.startsWith(cdkProjectDir.fsPath)) {
+                continue
+            }
+
+            // Get the cdk.out directory
+            const cdkOutDir = vscode.Uri.joinPath(project.treeUri, '..')
+
+            // Look for template.json files in cdk.out directory
+            const pattern = new vscode.RelativePattern(cdkOutDir.fsPath, '*.template.json')
+            const templateFiles = await vscode.workspace.findFiles(pattern)
+
+            for (const templateFile of templateFiles) {
+                try {
+                    // Read and parse the template.json file
+                    const templateContent = await fs.readFileText(templateFile)
+                    const template = JSON.parse(templateContent)
+
+                    // Search through resources for a Lambda function with matching FunctionName
+                    for (const [_, resource] of Object.entries(template.Resources || {})) {
+                        const res = resource as any
+                        if (
+                            res.Type === 'AWS::Lambda::Function' &&
+                            res.Properties?.FunctionName === functionConfig.FunctionName
+                        ) {
+                            // Found the matching function, extract the asset path from metadata
+                            const assetPath = res.Metadata?.['aws:asset:path']
+                            if (assetPath) {
+                                const assetDir = vscode.Uri.joinPath(cdkOutDir, assetPath)
+
+                                // Check if the asset directory exists
+                                if (await fs.exists(assetDir)) {
+                                    getLogger().info(`CDK outFile auto-detected from template.json: ${assetDir.fsPath}`)
+                                    return assetDir.fsPath
+                                }
+                            }
+                        }
+                    }
+                } catch (error) {
+                    getLogger().debug(`Failed to parse template file ${templateFile.fsPath}: ${error}`)
+                }
+            }
+        }
+    } catch (error) {
+        getLogger().warn(`Failed to auto-detect CDK outFile: ${error}`)
+    }
+
+    return undefined
+}
+
 /**
  * Helper function to check if a string is a valid VSCode glob pattern
  */
@@ -287,6 +391,15 @@ async function getVscodeDebugConfig(
     let vsCodeDebugConfig: vscode.DebugConfiguration
     switch (debugType) {
         case 'node':
+            // Try to auto-detect outFiles for TypeScript if not provided
+            if (debugConfig.sourceMap && !debugConfig.outFiles && debugConfig.handlerFile) {
+                const autoDetectedOutFile = await tryAutoDetectOutFile(debugConfig, functionConfig)
+                if (autoDetectedOutFile) {
+                    debugConfig.outFiles = [autoDetectedOutFile]
+                    getLogger().info(`outFile auto-detected: ${autoDetectedOutFile}`)
+                }
+            }
+
             // source map support
             if (debugConfig.sourceMap && debugConfig.outFiles) {
                 // process outFiles first, if they are relative path (not starting with /),

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

@@ -151,7 +151,6 @@ export class RemoteInvokeWebview extends VueWebview {
     private handlerFileAvailable: boolean = false
     private isStartingDebug: boolean = false
     private handlerFile: string | undefined
-    private outFile: string | undefined
     public constructor(
         private readonly channel: vscode.OutputChannel,
         private readonly client: LambdaClient,
@@ -412,25 +411,6 @@ export class RemoteInvokeWebview extends VueWebview {
         if (watchForUpdates && !isHotReloadingFunction(this.data.LambdaFunctionNode?.configuration.CodeSha256)) {
             this.setupFileWatcher()
         }
-        // try auto populate outFile for ts here
-        if (
-            (handlerFile.fsPath.endsWith('ts') || handlerFile.fsPath.endsWith('tsx')) &&
-            this.data.LambdaFunctionNode?.logicalId &&
-            this.data.LambdaFunctionNode.projectRoot
-        ) {
-            // if proj root is ..../sam-proj/
-            // build dir will be ..../sam-proj/.aws-sam/build/{LogicalID}/
-            const tmpPath = vscode.Uri.joinPath(
-                this.data.LambdaFunctionNode.projectRoot,
-                '.aws-sam',
-                'build',
-                this.data.LambdaFunctionNode.logicalId
-            )
-            if (await fs.exists(tmpPath)) {
-                this.outFile = tmpPath.fsPath
-                this.onStateChange.fire({})
-            }
-        }
         await openLambdaFile(handlerFile.fsPath)
         this.handlerFile = handlerFile.fsPath
         return true
@@ -651,6 +631,8 @@ export class RemoteInvokeWebview extends VueWebview {
             await RemoteDebugController.instance.startDebugging(this.data.FunctionArn, this.data.Runtime ?? 'unknown', {
                 ...config,
                 handlerFile: this.handlerFile,
+                samProjectLogicalId: this.data.LambdaFunctionNode.logicalId,
+                samProjectRoot: this.data.LambdaFunctionNode.projectRoot,
             })
         } catch (e) {
             throw ToolkitError.chain(
@@ -695,10 +677,6 @@ export class RemoteInvokeWebview extends VueWebview {
         return this.data.LocalRootPath ?? ''
     }
 
-    public getOutFile(): string {
-        return this.outFile ?? ''
-    }
-
     public getHandlerAvailable(): boolean {
         return this.handlerFileAvailable
     }

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

@@ -102,8 +102,8 @@
                         class="handler-status-message"
                     >
                         <info-wrap
-                            >Specify the path to your local directory that contains the handler file for debugging, or
-                            download the handler file from your deployed function.</info-wrap
+                            >Specify the absolute path to your local directory that contains the handler file for
+                            debugging, or download the handler file from your deployed function.</info-wrap
                         >
                     </div>
                     <div v-else style="margin-bottom: 3px" class="handler-status-message">

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

@@ -182,7 +182,6 @@ export default defineComponent({
                 this.debugState.isDebugging = await client.isWebViewDebugging()
                 this.debugConfig.localRootPath = await client.getLocalPath()
                 this.debugState.handlerFileAvailable = await client.getHandlerAvailable()
-                this.runtimeSettings.outFiles = await client.getOutFile()
                 // Get current session state
 
                 if (this.debugState.isDebugging) {