lambda-live-debugger 1.0.5 → 1.0.7

package/dist/frameworks/cdkFramework.mjs

@@ -142,21 +142,64 @@ export class CdkFramework {
      */
     async getLambdasDataFromCdkByCompilingAndRunning(cdkConfigPath, config) {
         const entryFile = await this.getCdkEntryFile(cdkConfigPath);
-        // Define a plugin to prepend custom code to .ts or .tsx files
+        let isESM = false;
+        const packageJsonPath = await findPackageJson(entryFile);
+        if (packageJsonPath) {
+            try {
+                const packageJson = JSON.parse(await fs.readFile(packageJsonPath, { encoding: 'utf-8' }));
+                if (packageJson.type === 'module') {
+                    isESM = true;
+                    Logger.verbose(`[CDK] Using ESM format`);
+                }
+            }
+            catch (err) {
+                Logger.error(`Error reading CDK package.json (${packageJsonPath}): ${err.message}`, err);
+            }
+        }
+        const rootDir = process.cwd();
+        // Plugin that:
+        // - Fixes __dirname issues
+        // - Injects code to get the file path of the Lambda function and CDK hierarchy
         const injectCodePlugin = {
             name: 'injectCode',
             setup(build) {
                 build.onLoad({ filter: /.*/ }, async (args) => {
-                    const absolutePath = path.resolve(args.path);
-                    let source = await fs.readFile(absolutePath, 'utf8');
+                    // fix __dirname issues
+                    const isWindows = /^win/.test(process.platform);
+                    const esc = (p) => (isWindows ? p.replace(/\\/g, '/') : p);
+                    const variables = `
+              const __fileloc = {
+                filename: "${esc(args.path)}",
+                dirname: "${esc(path.dirname(args.path))}",
+                relativefilename: "${esc(path.relative(rootDir, args.path))}",
+                relativedirname: "${esc(path.relative(rootDir, path.dirname(args.path)))}",
+                import: { meta: { url: "file://${esc(args.path)}" } }
+              };
+            `;
+                    let fileContent = new TextDecoder().decode(await fs.readFile(args.path));
+                    // remove shebang
+                    if (fileContent.startsWith('#!')) {
+                        const firstNewLine = fileContent.indexOf('\n');
+                        fileContent = fileContent.slice(firstNewLine + 1);
+                    }
+                    let contents;
+                    if (args.path.endsWith('.ts') || args.path.endsWith('.js')) {
+                        // add the variables at the top of the file, that contains the file location
+                        contents = `${variables}\n${fileContent}`;
+                    }
+                    else {
+                        contents = fileContent;
+                    }
+                    const loader = args.path.split('.').pop();
+                    // Inject code to get the file path of the Lambda function and CDK hierarchy
                     if (args.path.includes('aws-cdk-lib/aws-lambda/lib/function.')) {
                         const codeToFind = 'try{jsiiDeprecationWarnings().aws_cdk_lib_aws_lambda_FunctionProps(props)}';
-                        if (!source.includes(codeToFind)) {
+                        if (!contents.includes(codeToFind)) {
                             throw new Error(`Can not find code to inject in ${args.path}`);
                         }
                         // Inject code to get the file path of the Lambda function and CDK hierarchy
                         // path to match it with the Lambda function. Store data in the global variable.
-                        source = source.replace(codeToFind, `;
+                        contents = contents.replace(codeToFind, `;
               global.lambdas = global.lambdas ?? [];
 
               const lambdaInfo = {
@@ -180,36 +223,20 @@ export class CdkFramework {
                     }
                     if (args.path.includes('aws-cdk-lib/aws-s3-deployment/lib/bucket-deployment.')) {
                         const codeToFind = 'super(scope,id),this.requestDestinationArn=!1;';
-                        if (!source.includes(codeToFind)) {
+                        if (!contents.includes(codeToFind)) {
                             throw new Error(`Can not find code to inject in ${args.path}`);
                         }
                         // Inject code to prevent deploying the assets
-                        source = source.replace(codeToFind, codeToFind + `return;`);
+                        contents = contents.replace(codeToFind, codeToFind + `return;`);
                     }
                     return {
-                        contents: source,
-                        loader: 'default',
+                        contents,
+                        loader,
                     };
                 });
             },
         };
-        let isESM = false;
-        // get packgage.json
-        const packageJsonPath = await findPackageJson(entryFile);
-        if (packageJsonPath) {
-            try {
-                const packageJson = JSON.parse(await fs.readFile(packageJsonPath, { encoding: 'utf-8' }));
-                if (packageJson.type === 'module') {
-                    isESM = true;
-                    Logger.verbose(`[CDK] Using ESM format`);
-                }
-            }
-            catch (err) {
-                Logger.error(`Error reading CDK package.json (${packageJsonPath}): ${err.message}`, err);
-            }
-        }
         const compileOutput = path.join(getProjectDirname(), outputFolder, `compiledCdk.${isESM ? 'mjs' : 'cjs'}`);
-        const dirname = path.join(...[getProjectDirname(), config.subfolder, 'x'].filter((p) => p));
         try {
             // Build CDK code
             await esbuild.build({
@@ -228,7 +255,6 @@ export class CdkFramework {
                         banner: {
                             js: [
                                 `import { createRequire as topLevelCreateRequire } from 'module';`,
-                                `import.meta.url = 'file:///${dirname}/cdkFrameworkWorker.mjs';`,
                                 `global.require = global.require ?? topLevelCreateRequire(import.meta.url);`,
                                 `import { fileURLToPath as topLevelFileUrlToPath, URL as topLevelURL } from "url"`,
                                 `global.__dirname = global.__dirname ?? topLevelFileUrlToPath(new topLevelURL(".", import.meta.url))`,
@@ -238,10 +264,15 @@ export class CdkFramework {
                     : {
                         format: 'cjs',
                         target: 'node18',
-                        banner: {
-                            js: [`__dirname = '${dirname}';`].join('\n'),
-                        },
                     }),
+                define: {
+                    // replace __dirname,... with the a variable that contains the file location
+                    __filename: '__fileloc.filename',
+                    __dirname: '__fileloc.dirname',
+                    __relativefilename: '__fileloc.relativefilename',
+                    __relativedirname: '__fileloc.relativedirname',
+                    'import.meta.url': '__fileloc.import.meta.url',
+                },
             });
         }
         catch (error) {
@@ -359,7 +390,7 @@ export class CdkFramework {
         const contextFromLldConfig = config.context?.reduce((acc, arg) => {
             const [key, value] = arg.split('=');
             if (key && value) {
-                acc[key] = value;
+                acc[key.trim()] = value.trim();
             }
             return acc;
         }, {});

package/dist/frameworks/cdkFrameworkWorker.mjs

@@ -1,12 +1,5 @@
 // @ts-nocheck
-import { createRequire as topLevelCreateRequire } from 'module';
-const require = topLevelCreateRequire(import.meta.url);
-import path from 'path';
-
 import { workerData, parentPort } from 'node:worker_threads';
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-import fs from 'fs/promises'; // do not delete this line
-
 import { Logger } from '../logger.mjs';
 
 Logger.setVerbose(workerData.verbose);
@@ -18,10 +11,9 @@ parentPort.on('message', async (data) => {
     // this is global variable to store the data from the CDK code once it is executed
     global.lambdas = [];
 
-    Logger.verbose(`[Worker ${workerData.workerId}] Received message`, data);
+    Logger.verbose(`[Worker] Received message`, data);
 
     // execute code to get the data into global.lambdas
-    await fixCdkPaths(workerData.awsCdkLibPath);
     await import(data.compileOutput);
 
     if (!global.lambdas || global.lambdas?.length === 0) {
@@ -43,7 +35,7 @@ parentPort.on('message', async (data) => {
     }));
 
     Logger.verbose(
-      `[CDK] [Worker] Sending found lambdas`,
+      `[CDK] [Worker] Sending found Lambdas`,
       JSON.stringify(lambdas, null, 2),
     );
     parentPort.postMessage(lambdas);
@@ -53,91 +45,6 @@ parentPort.on('message', async (data) => {
   }
 });
 
-/**
- * Some paths are not resolved correctly in the CDK code, so we need to fix them
- */
-async function fixCdkPaths(awsCdkLibPath) {
-  // leave this lines for manual debugging
-  //const awsCdkLibPath = path.resolve("node_modules/aws-cdk-lib");
-  //const path = require("path");
-
-  Logger.verbose(`[CDK] [Worker] aws-cdk-lib PATH ${awsCdkLibPath}`);
-
-  const pathsFix = {
-    'custom-resource-handlers/': `${awsCdkLibPath}/custom-resource-handlers/`,
-    'aws-custom-resource-handler': `${awsCdkLibPath}/custom-resource-handlers/dist/custom-resources/aws-custom-resource-handler`,
-    'auto-delete-objects-handler': `${awsCdkLibPath}/custom-resource-handlers/dist/aws-s3/auto-delete-objects-handler`,
-    'notifications-resource-handler': `${awsCdkLibPath}/custom-resource-handlers/dist/aws-s3/notifications-resource-handler`,
-    'drop-spam-handler': `${awsCdkLibPath}/custom-resource-handlers/dist/aws-ses/drop-spam-handler`,
-    'aws-stepfunctions-tasks/role-policy-handler': `${awsCdkLibPath}/custom-resource-handlers/dist/aws-stepfunctions-tasks/role-policy-handler`,
-    'eval-nodejs-handler': `${awsCdkLibPath}/custom-resource-handlers/dist/aws-stepfunctions-tasks/eval-nodejs-handler`,
-    'cross-account-zone-delegation-handler': `${awsCdkLibPath}/custom-resource-handlers/dist/aws-route53/cross-account-zone-delegation-handler`,
-    'delete-existing-record-set-handler': `${awsCdkLibPath}/custom-resource-handlers/dist/aws-route53/delete-existing-record-set-handler`,
-    'aws-api-handler': `${awsCdkLibPath}/custom-resource-handlers/dist/aws-events-targets/aws-api-handler`,
-    'log-retention-handler': `${awsCdkLibPath}/custom-resource-handlers/dist/aws-logs/log-retention-handler`,
-    'cluster-resource-handler': `${awsCdkLibPath}/custom-resource-handlers/dist/aws-eks/cluster-resource-handler`,
-    'auto-delete-images-handler': `${awsCdkLibPath}/custom-resource-handlers/dist/aws-ecr/auto-delete-images-handler`,
-    'bucket-deployment-handler': `${awsCdkLibPath}/custom-resource-handlers/dist/aws-s3-deployment/bucket-deployment-handler`,
-    'nodejs-entrypoint-handler': `${awsCdkLibPath}/custom-resource-handlers/dist/core/nodejs-entrypoint-handler`,
-    'restrict-default-security-group-handler': `${awsCdkLibPath}/custom-resource-handlers/dist/aws-ec2/restrict-default-security-group-handler`,
-    'dns-validated-certificate-handler': `${awsCdkLibPath}/custom-resource-handlers/dist/aws-certificatemanager/dns-validated-certificate-handler`,
-    'auto-delete-underlying-resources-handler': `${awsCdkLibPath}/custom-resource-handlers/dist/aws-synthetics/auto-delete-underlying-resources-handler`,
-    'replica-handler': `${awsCdkLibPath}/custom-resource-handlers/dist/aws-dynamodb/replica-handler`,
-    'oidc-handler': `${awsCdkLibPath}/custom-resource-handlers/dist/aws-iam/oidc-handler`,
-  };
-
-  // Create a proxy to intercept calls to the path module so we can fix paths
-  const pathProxy = new Proxy(path, {
-    get(target, prop) {
-      if (typeof target[prop] === 'function') {
-        return function (...args) {
-          if (prop === 'resolve') {
-            let resolvedPath = target[prop].apply(target, args);
-
-            for (const [key, value] of Object.entries(pathsFix)) {
-              if (resolvedPath.includes(key)) {
-                // replace the beginning of the path with the value
-                const i = resolvedPath.indexOf(key);
-                const newResolvedPath = `${value}${resolvedPath.substring(i + key.length)}`;
-                Logger.verbose(
-                  `[CDK] [Worker] Fixing path ${resolvedPath} -> ${newResolvedPath}`,
-                );
-                resolvedPath = newResolvedPath;
-              }
-            }
-
-            return resolvedPath;
-          }
-          if (prop === 'join') {
-            let resolvedPath = target[prop].apply(target, args);
-
-            for (const [key, value] of Object.entries(pathsFix)) {
-              if (resolvedPath.includes(key)) {
-                // replace the beginning of the path with the value
-                const i = resolvedPath.indexOf(key);
-                const newResolvedPath = `${value}${resolvedPath.substring(i + key.length)}`;
-                Logger.verbose(
-                  `[CDK] [Worker] Fixing path ${resolvedPath} -> ${newResolvedPath}`,
-                );
-                resolvedPath = newResolvedPath;
-              }
-            }
-
-            return resolvedPath;
-          }
-          return target[prop].apply(target, args);
-        };
-      }
-      return target[prop];
-    },
-  });
-
-  // Override the path module in the require cache
-  require.cache[require.resolve('path')] = {
-    exports: pathProxy,
-  };
-}
-
 process.on('unhandledRejection', (error) => {
   Logger.error(`[CDK] [Worker] Unhandled Rejection`, error);
 });

package/dist/lambdaConnection.mjs

@@ -112,7 +112,7 @@ async function onMessageFromLambda(message) {
             await ioTServiceConnection.publish(payload, `${topic}/${message.data.workerId}`);
         }
         else {
-            // if we are in observable mode, mark the worker as processed
+            // if we are in Observability mode, mark the worker as processed
             lambdasProcessingObservableMode.delete(message.data.functionId);
         }
     }

package/dist/lldebugger.mjs

@@ -22,7 +22,6 @@ import { LambdaConnection } from './lambdaConnection.mjs';
 async function run() {
     const version = await getVersion();
     Logger.log(`Welcome to Lambda Live Debugger 🐞 version ${version}.`);
-    Logger.important('To keep the project moving forward, please fill out the feedback form at https://forms.gle/v6ekZtuB45Rv3EyW9. Your input is greatly appreciated!');
     await Configuration.readConfig();
     Logger.setVerbose(Configuration.config.verbose === true);
     Logger.verbose(`Parameters: \n${Object.entries(Configuration.config)
@@ -40,7 +39,7 @@ async function run() {
         return;
     }
     let message = `Starting the debugger ${Configuration.config.observable
-        ? 'in observable mode'
+        ? 'in Observability mode'
         : `(ID ${Configuration.config.debuggerId})`}...`;
     if (Configuration.config.remove) {
         message = `Removing Lambda Live Debugger${Configuration.config.remove === 'all' ? ' including layer' : ''}...`;

package/dist/logger.mjs

@@ -1,5 +1,4 @@
 import chalk from 'chalk';
-const orange = '#D24E01';
 let verboseEnabled = false;
 /**
  * Log a message
@@ -20,7 +19,7 @@ function log(...args) {
  * @param args The arguments to log
  */
 function important(...args) {
-    args = args.map((arg) => typeof arg === 'string' ? chalk.hex(orange)(arg) : arg);
+    args = args.map((arg) => (typeof arg === 'string' ? chalk.yellow(arg) : arg));
     console.log(...args);
 }
 /**
@@ -36,7 +35,7 @@ function error(...args) {
  * @param args The arguments to log
  */
 function warn(...args) {
-    args = args.map((arg) => typeof arg === 'string' ? chalk.hex(orange)(arg) : arg);
+    args = args.map((arg) => (typeof arg === 'string' ? chalk.yellow(arg) : arg));
     console.warn(...args);
 }
 /**

package/dist/nodeWorker.mjs

@@ -22,23 +22,31 @@ async function runInWorker(input) {
                 environment: input.environment,
                 verbose: Configuration.config.verbose,
             });
+            worker.used = false;
+            worker.toKill = false;
         }
         else {
             Logger.verbose(`[Function ${input.fuctionRequest.functionId}] [Worker ${input.fuctionRequest.workerId}] Reusing worker`);
         }
-        worker.on('message', (msg) => {
+        worker.onMessage = (msg) => {
             Logger.verbose(`[Function ${input.fuctionRequest.functionId}] [Worker ${input.fuctionRequest.workerId}] Worker message`, JSON.stringify(msg));
+            worker.used = false;
             if (msg?.errorType) {
                 reject(msg);
             }
             else {
                 resolve(msg);
             }
-        });
-        worker.on('error', (err) => {
+            if (worker.toKill) {
+                worker.toKill = false;
+                void worker.terminate();
+            }
+        };
+        worker.onError = (err) => {
             Logger.error(`[Function ${input.fuctionRequest.functionId}] [Worker ${input.fuctionRequest.workerId}] Error`, err);
             reject(err);
-        });
+        };
+        worker.used = true;
         worker.postMessage({
             env: input.fuctionRequest.env,
             event: input.fuctionRequest.event,
@@ -78,6 +86,12 @@ function startWorker(input) {
         workers.delete(input.workerId);
     });
     workers.set(input.workerId, worker);
+    worker.on('message', (msg) => {
+        worker?.onMessage?.(msg);
+    });
+    worker.on('error', (err) => {
+        worker?.onError?.(err);
+    });
     return worker;
 }
 /**
@@ -87,7 +101,19 @@ async function stopAllWorkers() {
     Logger.verbose('Stopping all workers');
     const promises = [];
     for (const worker of workers.values()) {
-        promises.push(worker.terminate());
+        if (worker.used) {
+            worker.toKill = true;
+            // set timout for 5 minutes and kill the worker if it is still running
+            setTimeout(() => {
+                if (worker.toKill) {
+                    worker.toKill = false;
+                    void worker.terminate();
+                }
+            }, 300000);
+        }
+        else {
+            promises.push(worker.terminate());
+        }
     }
     workers.clear();
     await Promise.all(promises);

package/dist/nodeWorkerRunner.mjs

@@ -13,16 +13,16 @@ Logger.verbose(
 
 parentPort.on('message', async (data) => {
   Logger.verbose(`[Worker ${workerData.workerId}] Received message`, data);
-  const mod = await import(workerData.artifactFile);
-  const fn = mod[workerData.handler];
+  try {
+    const mod = await import(workerData.artifactFile);
+    const fn = mod[workerData.handler];
 
-  if (!fn) {
-    throw new Error(
-      `Handler '${workerData.handler}' not found for function '${workerData.functionId}'`,
-    );
-  }
+    if (!fn) {
+      throw new Error(
+        `Handler '${workerData.handler}' not found for function '${workerData.functionId}'`,
+      );
+    }
 
-  try {
     const context = {
       ...data.context,
       getRemainingTimeInMillis: () => 2147483647, // Max 32-bit signed integer

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lambda-live-debugger",
-  "version": "1.0.5",
+  "version": "1.0.7",
   "type": "module",
   "description": "Debug Lambda functions locally like it is running in the cloud",
   "repository": {