feat: JetBrains IDE tools support

Author: ServerlessLife

package-lock.json

@@ -115,6 +115,7 @@
     "chokidar": "^3.6.0",
     "commander": "^13.1.0",
     "esbuild": "^0.25.0",
+    "fast-xml-parser": "^5.0.8",
     "inquirer": "^12.4.2",
     "jsonc-parser": "^3.3.1",
     "node-machine-id": "^1.1.12",
@@ -133,6 +134,7 @@
     "aws-iot-device-sdk",
     "chokidar",
     "commander",
+    "fast-xml-parser",
     "node-machine-id",
     "toml",
     "yaml",

package.json

@@ -17,6 +17,7 @@ import { GitIgnore } from '../gitignore.js';
 import { VsCode } from '../vsCode.js';
 import { Logger } from '../logger.js';
 import { Configuration } from '../configuration.js';
+import { JetBrains } from '../jetBrains.js';
 
 const configFileName = path.resolve(configFileDefaultName);
 
@@ -335,6 +336,19 @@ export async function getConfigFromWizard({
         answers.vscode = answersVsCode.vscode;
       }
 
+      if (!(await JetBrains.isConfigured())) {
+        const answersJetBrains = await inquirer.prompt([
+          {
+            type: 'confirm',
+            name: 'jetbrains',
+            message: `Would you like to add configuration for JetBrains IDE, like WebStorm?`,
+            default: false,
+          },
+        ]);
+
+        answers.jetbrains = answersJetBrains.jetbrains;
+      }
+
       const answersVerbose = await inquirer.prompt([
         {
           type: 'confirm',
@@ -464,6 +478,7 @@ function getConfigFromAnswers(answers: any): LldConfigCliArgs {
     interactive: answers.interactive,
     gitignore: answers.gitignore,
     vscode: answers.vscode,
+    jetbrains: answers.jetbrains,
   };
 
   //remove undefined and empty strings

src/configuration/getConfigFromWizard.ts

@@ -0,0 +1,138 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { XMLParser, XMLBuilder } from 'fast-xml-parser';
+import { getProjectDirname } from './getDirname.js';
+import { Logger } from './logger.js';
+import { getRuntimeExecutableForIde } from './utils/getRuntimeExecutableForIde.js';
+
+const workspaceXmlPath = path.join(
+  getProjectDirname(),
+  '.idea',
+  'workspace.xml',
+);
+
+async function getWebStormLaunchConfig() {
+  let runtimeExecutable = await getRuntimeExecutableForIde();
+  runtimeExecutable = runtimeExecutable.replace(
+    '${workspaceFolder}',
+    '$PROJECT_DIR$',
+  );
+  return {
+    configuration: {
+      '@_name': 'Lambda Live Debugger',
+      '@_type': 'NodeJSConfigurationType',
+      '@_path-to-js-file': runtimeExecutable,
+      '@_working-dir': '$PROJECT_DIR$',
+      method: { '@_v': '2' },
+    },
+  };
+}
+
+async function readWorkspaceXml(
+  filePath: string,
+): Promise<{ json: any; xmlString: string }> {
+  try {
+    const xmlString = await fs.readFile(filePath, 'utf-8');
+    const parser = new XMLParser({
+      ignoreAttributes: false,
+      allowBooleanAttributes: true,
+    });
+    const json = parser.parse(xmlString);
+    return { json, xmlString };
+  } catch (err: any) {
+    if (err.code === 'ENOENT') {
+      return { json: null, xmlString: '' };
+    }
+    throw new Error(`Error reading ${filePath}`, { cause: err });
+  }
+}
+
+async function writeWorkspaceXml(filePath: string, json: any) {
+  try {
+    const builder = new XMLBuilder({
+      ignoreAttributes: false,
+      format: true,
+      suppressEmptyNode: true,
+      suppressBooleanAttributes: false,
+    });
+    const xmlString = builder.build(json);
+    await fs.writeFile(filePath, xmlString, 'utf-8');
+    Logger.verbose(`Updated WebStorm configuration at ${filePath}`);
+  } catch (err) {
+    throw new Error(`Error writing ${filePath}`, { cause: err });
+  }
+}
+
+async function isConfigured() {
+  const { json } = await readWorkspaceXml(workspaceXmlPath);
+  if (!json) return false;
+
+  const components = Array.isArray(json.project?.component)
+    ? json.project.component
+    : [json.project?.component];
+  const runManager = components.find((c: any) => c['@_name'] === 'RunManager');
+  if (!runManager) return false;
+
+  const configurations = runManager.configuration || [];
+  return configurations.some(
+    (c: any) => c['@_name'] === 'Lambda Live Debugger',
+  );
+}
+
+async function addConfiguration() {
+  Logger.verbose('Adding WebStorm run/debug configuration');
+  const { json } = await readWorkspaceXml(workspaceXmlPath);
+  const config = await getWebStormLaunchConfig();
+
+  if (!json) {
+    // Create new workspace.xml if it does not exist
+    const newJson = {
+      '?xml': { '@_version': '1.0', '@_encoding': 'UTF-8' },
+      project: {
+        '@_version': '4',
+        component: {
+          '@_name': 'RunManager',
+          configuration: [config.configuration],
+        },
+      },
+    };
+    await fs.mkdir(path.dirname(workspaceXmlPath), { recursive: true });
+    await writeWorkspaceXml(workspaceXmlPath, newJson);
+    return;
+  }
+
+  let runManager = json.project.component.find(
+    (c: any) => c['@_name'] === 'RunManager',
+  );
+
+  if (!runManager) {
+    Logger.verbose('RunManager not found, creating new RunManager component');
+    runManager = { '@_name': 'RunManager', configuration: [] };
+    json.project.component.push(runManager);
+  }
+
+  let configurations;
+  if (!runManager.configuration) {
+    configurations = [];
+  } else if (!Array.isArray(runManager.configuration)) {
+    configurations = [runManager.configuration];
+  } else {
+    configurations = runManager.configuration;
+  }
+
+  const exists = configurations.some(
+    (c: any) => c['@_name'] === config.configuration['@_name'],
+  );
+  if (!exists) {
+    Logger.verbose('Adding new configuration to workspace.xml');
+    runManager.configuration = [...configurations, config.configuration];
+    await writeWorkspaceXml(workspaceXmlPath, json);
+  } else {
+    Logger.verbose('Configuration already exists in workspace.xml');
+  }
+}
+
+export const JetBrains = {
+  isConfigured,
+  addConfiguration,
+};

src/jetBrains.ts

@@ -17,6 +17,7 @@ import { Logger } from './logger.js';
 import { getModuleDirname, getProjectDirname } from './getDirname.js';
 import { LambdaConnection } from './lambdaConnection.js';
 import inquirer from 'inquirer';
+import { JetBrains } from './jetBrains.js';
 
 /**
  * Start the Lambda Live Debugger
@@ -46,6 +47,10 @@ async function run() {
     await VsCode.addConfiguration();
   }
 
+  if (Configuration.config.jetbrains) {
+    await JetBrains.addConfiguration();
+  }
+
   if (!Configuration.config.start && !Configuration.config.remove) {
     return;
   }

src/lldebugger.ts

@@ -78,6 +78,7 @@ export type LldConfigBase = {
 export type LldConfigCliArgs = {
   remove?: 'keep-layer' | 'all';
   vscode?: boolean;
+  jetbrains?: boolean;
   gitignore?: boolean;
   config?: string;
   wizard?: boolean;

src/types/lldConfig.ts

@@ -0,0 +1,92 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { getModuleDirname, getProjectDirname } from '../getDirname.js';
+import { Logger } from '../logger.js';
+
+/**
+ * Get the runtime executable for the IDE, like WebStorm or VSCode
+ * @returns
+ */
+export async function getRuntimeExecutableForIde() {
+  let runtimeExecutable: string | undefined;
+  const localRuntimeExecutable = '${workspaceFolder}/node_modules/.bin/lld';
+
+  const moduleDirname = getModuleDirname();
+  const projectDirname = getProjectDirname();
+
+  const localFolder = path.resolve(
+    path.join(projectDirname, 'node_modules/.bin/lld'),
+  );
+
+  //if installed locally
+  if (moduleDirname.startsWith('/home/')) {
+    Logger.verbose('Lambda Live Debugger is installed locally');
+    // check if file exists
+    try {
+      Logger.verbose(
+        'Checking local folder for runtimeExecutable setting for VsCode configuration',
+        localFolder,
+      );
+      await fs.access(localFolder, fs.constants.F_OK);
+      runtimeExecutable = localRuntimeExecutable;
+    } catch {
+      // Not found
+    }
+  } else {
+    Logger.verbose('Lambda Live Debugger is installed globally');
+  }
+
+  if (!runtimeExecutable) {
+    Logger.verbose(
+      `Setting absolute path for runtimeExecutable setting for VsCode configuration`,
+    );
+    const localFolderSubfolder = path.resolve('node_modules/.bin/lld');
+    const globalModule1 = path.join(moduleDirname, '..', '..', '.bin/lld');
+    const globalModule2 = path.join(moduleDirname, '..', '..', 'bin/lld');
+    const globalModule3 = path.join(
+      moduleDirname,
+      '..',
+      '..',
+      '..',
+      '..',
+      'bin/lld',
+    );
+    const possibleFolders = {
+      [localFolder]: '${workspaceFolder}/node_modules/.bin/lld',
+      [localFolderSubfolder]: localFolderSubfolder,
+      [globalModule1]: globalModule1,
+      [globalModule2]: globalModule2,
+      [globalModule3]: globalModule3,
+    };
+
+    Logger.verbose(
+      `Checking the following possible folders for lld executable:`,
+      JSON.stringify(possibleFolders, null, 2),
+    );
+
+    // check each possible folder and set the runtimeExecutable
+    for (const folder in possibleFolders) {
+      try {
+        //Logger.log("Checking folder", folder);
+        await fs.access(folder, fs.constants.F_OK);
+        runtimeExecutable = possibleFolders[folder];
+        Logger.verbose(`Found folder with lld executable: ${folder}`);
+        break;
+      } catch {
+        // Not found
+      }
+    }
+
+    if (!runtimeExecutable) {
+      Logger.error(
+        `Could not find lld executable. Please check your IDE debugger settings.`,
+      );
+    }
+  }
+
+  if (!runtimeExecutable) {
+    return localRuntimeExecutable;
+  }
+
+  return runtimeExecutable;
+}