@gatling.io/cli 3.11.3-M1 → 3.11.4-M1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gatling.io/cli",
-  "version": "3.11.3-M1",
+  "version": "3.11.4-M1",
   "license": "Apache-2.0",
   "bin": {
     "gatling": "target/index.js"
@@ -8,6 +8,7 @@
   "main": "target/index.js",
   "types": "target/index.d.ts",
   "dependencies": {
+    "archiver": "7.0.1",
     "axios": "1.6.8",
     "commander": "12.0.0",
     "decompress": "4.2.1",
@@ -15,6 +16,7 @@
     "esbuild-plugin-tsc": "0.4.0"
   },
   "devDependencies": {
+    "@types/archiver": "6.0.2",
     "@types/decompress": "4.2.7",
     "@types/node": "20.12.12",
     "prettier": "3.2.5",

package/target/bundle.d.ts

@@ -1,6 +1,8 @@
+import { SimulationFile } from "./simulations";
 export interface BundleOptions {
     sourcesFolder: string;
     bundleFile: string;
     typescript: boolean;
+    simulations: SimulationFile[];
 }
 export declare const bundle: (options: BundleOptions) => Promise<void>;

package/target/bundle.js

@@ -29,17 +29,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.bundle = void 0;
 const esbuild = __importStar(require("esbuild"));
 const esbuild_plugin_tsc_1 = __importDefault(require("esbuild-plugin-tsc"));
-const promises_1 = __importDefault(require("fs/promises"));
 const log_1 = require("./log");
 const bundle = async (options) => {
-    log_1.logger.info(`Packaging a Gatling simulation with options:
+    log_1.logger.info(`Bundling a Gatling simulation with options:
  - sourcesFolder: ${options.sourcesFolder}
- - bundleFile: ${options.bundleFile}`);
-    const children = await promises_1.default.readdir(options.sourcesFolder, { recursive: false });
-    const contents = children
-        .filter((f) => (options.typescript ? f.endsWith(".gatling.ts") : f.endsWith(".gatling.js")))
-        .map((f) => `export { default as "${f.slice(0, -11)}" } from "./${f}";`)
-        .join("\n");
+ - bundleFile: ${options.bundleFile}
+ - typescript: ${options.typescript}`);
+    const contents = options.simulations.map((s) => `export { default as "${s.name}" } from "./${s.path}";`).join("\n");
     const plugins = options.typescript ? [(0, esbuild_plugin_tsc_1.default)({ force: true })] : [];
     await esbuild.build({
         stdin: {

package/target/dependencies/coursier.d.ts

@@ -1,2 +1,3 @@
 export declare const installCoursier: (gatlingHomeDir: string, downloadDir: string) => Promise<string>;
-export declare const resolveDependencies: (coursierPath: string, javaHome: string) => Promise<string>;
+export declare const resolveGatlingJsDependencies: (coursierPath: string, javaHome: string) => Promise<string>;
+export declare const resolveRecorderDependencies: (coursierPath: string, javaHome: string) => Promise<string>;

package/target/dependencies/coursier.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolveDependencies = exports.installCoursier = void 0;
+exports.resolveRecorderDependencies = exports.resolveGatlingJsDependencies = exports.installCoursier = void 0;
 const fs_1 = require("fs");
 const promises_1 = __importDefault(require("fs/promises"));
 const download_1 = require("./download");
@@ -46,15 +46,23 @@ const installCoursier = async (gatlingHomeDir, downloadDir) => {
     return coursierPath;
 };
 exports.installCoursier = installCoursier;
-const resolveDependencies = async (coursierPath, javaHome) => {
+const resolveGatlingJsDependencies = async (coursierPath, javaHome) => {
     const gatlingDep = `"io.gatling.highcharts:gatling-charts-highcharts:${versions_1.versions.gatling.core}"`;
     const gatlingAdapterDep = `"io.gatling:gatling-jvm-to-js-adapter:${versions_1.versions.gatling.jsAdapter}"`;
     const graalvmJsDep = `"org.graalvm.polyglot:js-community:${versions_1.versions.graalvm.js}"`;
-    const command = `"${coursierPath}" fetch --classpath ${gatlingDep} ${gatlingAdapterDep} ${graalvmJsDep}`;
+    return await resolveDependencies(coursierPath, javaHome, gatlingDep, gatlingAdapterDep, graalvmJsDep);
+};
+exports.resolveGatlingJsDependencies = resolveGatlingJsDependencies;
+const resolveRecorderDependencies = async (coursierPath, javaHome) => {
+    const recorderDep = `io.gatling:gatling-recorder:${versions_1.versions.gatling.core}`;
+    return await resolveDependencies(coursierPath, javaHome, recorderDep);
+};
+exports.resolveRecorderDependencies = resolveRecorderDependencies;
+const resolveDependencies = async (coursierPath, javaHome, ...dependencies) => {
+    const command = `"${coursierPath}" fetch --classpath ${dependencies.join(" ")}`;
     // TODO could add a timeout
     log_1.logger.info(`Resolving dependencies with Coursier`);
     const { stdout } = await execAsync(command, { env: { ...process.env, JAVA_HOME: javaHome } });
     return stdout;
 };
-exports.resolveDependencies = resolveDependencies;
 const execAsync = (0, util_1.promisify)(child_process_1.exec);

package/target/dependencies/index.d.ts

@@ -6,4 +6,5 @@ export interface ResolvedDependencies {
     coursierBinary: string;
     jvmClasspath: string;
 }
-export declare const installAll: (options: DependenciesOptions) => Promise<ResolvedDependencies>;
+export declare const installGatlingJs: (options: DependenciesOptions) => Promise<ResolvedDependencies>;
+export declare const installRecorder: (options: DependenciesOptions) => Promise<ResolvedDependencies>;

package/target/dependencies/index.js

@@ -3,20 +3,33 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.installAll = void 0;
+exports.installRecorder = exports.installGatlingJs = void 0;
 const promises_1 = __importDefault(require("fs/promises"));
 const coursier_1 = require("./coursier");
 const graalVm_1 = require("./graalVm");
-const installAll = async (options) => {
+const installGatlingJs = async (options) => {
     const downloadDir = `${options.gatlingHome}/tmp/download`;
     await promises_1.default.mkdir(downloadDir, { recursive: true });
     const graalvmHomePath = await (0, graalVm_1.installGraalVm)(options.gatlingHome, downloadDir);
     const coursierPath = await (0, coursier_1.installCoursier)(options.gatlingHome, downloadDir);
-    const classpath = await (0, coursier_1.resolveDependencies)(coursierPath, graalvmHomePath);
+    const classpath = await (0, coursier_1.resolveGatlingJsDependencies)(coursierPath, graalvmHomePath);
     return {
         graalvmHome: graalvmHomePath,
         coursierBinary: coursierPath,
         jvmClasspath: classpath.trim()
     };
 };
-exports.installAll = installAll;
+exports.installGatlingJs = installGatlingJs;
+const installRecorder = async (options) => {
+    const downloadDir = `${options.gatlingHome}/tmp/download`;
+    await promises_1.default.mkdir(downloadDir, { recursive: true });
+    const graalvmHomePath = await (0, graalVm_1.installGraalVm)(options.gatlingHome, downloadDir);
+    const coursierPath = await (0, coursier_1.installCoursier)(options.gatlingHome, downloadDir);
+    const classpath = await (0, coursier_1.resolveRecorderDependencies)(coursierPath, graalvmHomePath);
+    return {
+        graalvmHome: graalvmHomePath,
+        coursierBinary: coursierPath,
+        jvmClasspath: classpath.trim()
+    };
+};
+exports.installRecorder = installRecorder;

package/target/dependencies/versions.js

@@ -8,7 +8,7 @@ exports.versions = {
     },
     coursier: "2.1.10",
     gatling: {
-        core: "3.11.2",
-        jsAdapter: "3.11.3-M1"
+        core: "3.11.3",
+        jsAdapter: "3.11.4-M1"
     }
 };

package/target/enterprisePackage.d.ts

@@ -0,0 +1,8 @@
+import { SimulationFile } from "./simulations";
+export interface EnterprisePackageOptions {
+    bundleFile: string;
+    resourcesFolder: string;
+    enterprisePackageFile: string;
+    simulations: SimulationFile[];
+}
+export declare const enterprisePackage: (options: EnterprisePackageOptions) => Promise<void>;

package/target/enterprisePackage.js

@@ -0,0 +1,82 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enterprisePackage = void 0;
+const archiver_1 = __importDefault(require("archiver"));
+const fs_1 = __importDefault(require("fs"));
+const promises_1 = require("stream/promises");
+const zlib_1 = require("zlib");
+const versions_1 = require("./dependencies/versions");
+const log_1 = require("./log");
+const enterprisePackage = async (options) => {
+    log_1.logger.info(`Packaging a Gatling simulation with options:
+ - bundleFile: ${options.bundleFile}
+ - enterprisePackageFile: ${options.enterprisePackageFile}`);
+    const manifest = generateManifest(options.simulations.map((s) => s.name));
+    const output = fs_1.default.createWriteStream(options.enterprisePackageFile);
+    const archive = (0, archiver_1.default)("zip", {
+        zlib: { level: zlib_1.constants.Z_MAX_LEVEL }
+    });
+    archive.on("warning", (err) => {
+        // The pipeline will rethrow errors but not warnings. We don't want to ignore warnings from the archiver, because
+        // they include things like 'no such file or directory'.
+        throw err;
+    });
+    archive.file(options.bundleFile, { name: "bundle.js" });
+    archive.append(Buffer.from(manifest), { name: "META-INF/MANIFEST.MF" });
+    archive.directory(options.resourcesFolder + "/", false);
+    archive.finalize();
+    await (0, promises_1.pipeline)(archive, output);
+    log_1.logger.info(`Package for Gatling Enterprise created at ${options.enterprisePackageFile}`);
+};
+exports.enterprisePackage = enterprisePackage;
+const generateManifest = (simulationNames) => {
+    const utf8Encoder = new TextEncoder();
+    const eol = utf8Encoder.encode("\n");
+    const continuation = utf8Encoder.encode("\n ");
+    const lines = [
+        "Manifest-Version: 1.0",
+        "Implementation-Title: gatling-javascript",
+        `Implementation-Version: ${versions_1.versions.gatling.jsAdapter}`,
+        "Implementation-Vendor: GatlingCorp",
+        "Specification-Vendor: GatlingCorp",
+        "Gatling-Context: js",
+        `Gatling-Version: ${versions_1.versions.gatling.core}`,
+        "Gatling-Packager: javascript",
+        `Gatling-Packager-Version: ${versions_1.versions.gatling.jsAdapter}`,
+        `Gatling-Simulations: ${simulationNames.join(",")}`,
+        `Java-Version: ${versions_1.versions.graalvm.jdk.split(".")[0]}`
+    ];
+    let totalLength = 0;
+    const buffer = [];
+    for (const line of lines) {
+        let lineLength = 0;
+        for (const char of line) {
+            const bytes = utf8Encoder.encode(char);
+            const byteLength = bytes.byteLength;
+            if (lineLength + byteLength > 71) {
+                buffer.push(continuation);
+                buffer.push(bytes);
+                // reset length for the new line (with +1 for leading space)
+                lineLength = byteLength + 1;
+                totalLength += byteLength + 2;
+            }
+            else {
+                buffer.push(bytes);
+                lineLength += byteLength;
+                totalLength += byteLength;
+            }
+        }
+        buffer.push(eol);
+        totalLength += 1;
+    }
+    const manifest = new Uint8Array(totalLength);
+    let cursor = 0;
+    for (const elt of buffer) {
+        manifest.set(elt, cursor);
+        cursor += elt.byteLength;
+    }
+    return manifest;
+};

package/target/index.js

@@ -8,6 +8,8 @@ const commander_1 = require("commander");
 const os_1 = __importDefault(require("os"));
 const bundle_1 = require("./bundle");
 const dependencies_1 = require("./dependencies");
+const enterprisePackage_1 = require("./enterprisePackage");
+const simulations_1 = require("./simulations");
 const log_1 = require("./log");
 const run_1 = require("./run");
 const program = new commander_1.Command()
@@ -17,11 +19,30 @@ const program = new commander_1.Command()
 const gatlingHomeOption = new commander_1.Option("--gatling-home <value>", 'The folder used to download and install Gatling components (default: "~/.gatling")');
 const gatlingHomeDirWithDefaults = (options) => options.gatlingHome || `${os_1.default.homedir()}/.gatling`;
 const sourcesFolderOption = new commander_1.Option("--sources-folder <value>", "The sources folder path").default("src");
-const simulationOption = new commander_1.Option("--simulation <value>", "The simulation entry point function name").default("default", '"default", compatible with using "export default"');
-const bundleFileOption = new commander_1.Option("--bundle-file <value>", "The simulation target bundle file path").default("target/bundle.js");
+const simulationOption = new commander_1.Option("--simulation <value>", "The simulation entry point function name (default: if only one *.gatling.js or *.gatling.ts file is found, will execute that simulation)");
+const simulationWithDefaults = (options, simulationsFound) => {
+    if (options.simulation !== undefined) {
+        return options.simulation;
+    }
+    else if (simulationsFound.length === 1) {
+        return simulationsFound[0].name;
+    }
+    else if (simulationsFound.length === 0) {
+        throw new Error("No simulation found, simulations must be defined in a <simulation name>.gatling.js or <simulation name>.gatling.ts file)");
+    }
+    else {
+        throw new Error(`Several simulations found, specify one using the --simulation option (available simulations: ${simulationsFound.map((s) => s.name)})`);
+    }
+};
+const simulationRequiredOption = new commander_1.Option("--simulation <value>", "The simulation entry point function name").makeOptionMandatory(true);
+const bundleFileOption = new commander_1.Option("--bundle-file <value>", "The target bundle file path when building simulations").default("target/bundle.js");
+const enterprisePackageFileOption = new commander_1.Option("--enterprise-package-file <value>", "The target package file path when packaging simulations for Gatling Enterprise").default("target/package.jar");
 const resourcesFolderOption = new commander_1.Option("--resources-folder <value>", "The resources folder path").default("resources");
 const resultsFolderOption = new commander_1.Option("--results-folder <value>", "The results folder path").default("target/gatling");
-const typescriptOption = new commander_1.Option("--typescript", "Use the typescript compiler to compile your code").default(false);
+const typescriptOption = new commander_1.Option("--typescript", "Use the typescript compiler to compile your code (default: true if the sourcesFolder contains any *.gatling.ts file, false otherwise)");
+const typescriptWithDefaults = (options, simulationsFound) => options.typescript !== undefined
+    ? options.typescript
+    : simulationsFound.findIndex((s) => s.type === "typescript") >= 0;
 const graalvmHomeMandatoryOption = new commander_1.Option("--graalvm-home <value>", "Path to the GraalVM home").makeOptionMandatory(true);
 const jvmClasspathMandatoryOption = new commander_1.Option("--jvm-classpath <value>", "The classpath containing all Gatling JVM components").makeOptionMandatory(true);
 program
@@ -30,29 +51,30 @@ program
     .addOption(gatlingHomeOption)
     .action(async (options) => {
     const gatlingHome = gatlingHomeDirWithDefaults(options);
-    const { graalvmHome, coursierBinary, jvmClasspath } = await (0, dependencies_1.installAll)({ gatlingHome });
+    const { graalvmHome, coursierBinary, jvmClasspath } = await (0, dependencies_1.installGatlingJs)({ gatlingHome });
     log_1.logger.info(`graalvmHome=${graalvmHome}`);
     log_1.logger.info(`coursierBinary=${coursierBinary}`);
     log_1.logger.info(`jvmClasspath=${jvmClasspath}`);
 });
 program
     .command("build")
-    .description("Build a Gatling simulation")
+    .description("Build Gatling simulations")
     .addOption(sourcesFolderOption)
     .addOption(bundleFileOption)
     .addOption(typescriptOption)
     .action(async (options) => {
     const sourcesFolder = options.sourcesFolder;
     const bundleFile = options.bundleFile;
-    const typescript = options.typescript;
-    await (0, bundle_1.bundle)({ sourcesFolder, bundleFile, typescript });
+    const simulations = await (0, simulations_1.findSimulations)(sourcesFolder);
+    const typescript = typescriptWithDefaults(options, simulations);
+    await (0, bundle_1.bundle)({ sourcesFolder, bundleFile, typescript, simulations });
 });
 program
     .command("run-only")
-    .description("Run a Gatling simulation")
+    .description("Run a Gatling simulation from an already built bundle")
     .addOption(graalvmHomeMandatoryOption)
     .addOption(jvmClasspathMandatoryOption)
-    .addOption(simulationOption)
+    .addOption(simulationRequiredOption)
     .addOption(bundleFileOption)
     .addOption(resourcesFolderOption)
     .addOption(resultsFolderOption)
@@ -63,7 +85,14 @@ program
     const bundleFile = options.bundleFile;
     const resourcesFolder = options.resourcesFolder;
     const resultsFolder = options.resultsFolder;
-    await (0, run_1.run)({ graalvmHome, jvmClasspath, simulation: simulation, bundleFile, resourcesFolder, resultsFolder });
+    await (0, run_1.runSimulation)({
+        graalvmHome,
+        jvmClasspath,
+        simulation: simulation,
+        bundleFile,
+        resourcesFolder,
+        resultsFolder
+    });
 });
 program
     .command("run")
@@ -78,16 +107,54 @@ program
     .action(async (options) => {
     const gatlingHome = gatlingHomeDirWithDefaults(options);
     const sourcesFolder = options.sourcesFolder;
-    const simulation = options.simulation;
     const bundleFile = options.bundleFile;
     const resourcesFolder = options.resourcesFolder;
     const resultsFolder = options.resultsFolder;
-    const typescript = options.typescript;
-    const { graalvmHome, coursierBinary, jvmClasspath } = await (0, dependencies_1.installAll)({ gatlingHome });
+    const simulations = await (0, simulations_1.findSimulations)(sourcesFolder);
+    const typescript = typescriptWithDefaults(options, simulations);
+    const simulation = simulationWithDefaults(options, simulations);
+    const { graalvmHome, coursierBinary, jvmClasspath } = await (0, dependencies_1.installGatlingJs)({ gatlingHome });
+    log_1.logger.debug(`graalvmHome=${graalvmHome}`);
+    log_1.logger.debug(`coursierBinary=${coursierBinary}`);
+    log_1.logger.debug(`jvmClasspath=${jvmClasspath}`);
+    await (0, bundle_1.bundle)({ sourcesFolder, bundleFile, typescript, simulations });
+    await (0, run_1.runSimulation)({ graalvmHome, jvmClasspath, simulation, bundleFile, resourcesFolder, resultsFolder });
+});
+program
+    .command("recorder")
+    .description("Run the Gatling recorder")
+    .addOption(gatlingHomeOption)
+    .addOption(sourcesFolderOption)
+    .addOption(typescriptOption)
+    .addOption(resourcesFolderOption)
+    .action(async (options) => {
+    const gatlingHome = gatlingHomeDirWithDefaults(options);
+    const sourcesFolder = options.sourcesFolder;
+    const resourcesFolder = options.resourcesFolder;
+    const simulations = await (0, simulations_1.findSimulations)(sourcesFolder);
+    const typescript = typescriptWithDefaults(options, simulations);
+    const { graalvmHome, coursierBinary, jvmClasspath } = await (0, dependencies_1.installRecorder)({ gatlingHome });
     log_1.logger.debug(`graalvmHome=${graalvmHome}`);
     log_1.logger.debug(`coursierBinary=${coursierBinary}`);
     log_1.logger.debug(`jvmClasspath=${jvmClasspath}`);
-    await (0, bundle_1.bundle)({ sourcesFolder, bundleFile, typescript });
-    await (0, run_1.run)({ graalvmHome, jvmClasspath, simulation, bundleFile, resourcesFolder, resultsFolder });
+    await (0, run_1.runRecorder)({ graalvmHome, jvmClasspath, sourcesFolder, typescript, resourcesFolder });
+});
+program
+    .command("enterprise-package")
+    .description("Build Gatling simulations and package them for Gatling Enterprise")
+    .addOption(sourcesFolderOption)
+    .addOption(resourcesFolderOption)
+    .addOption(bundleFileOption)
+    .addOption(enterprisePackageFileOption)
+    .addOption(typescriptOption)
+    .action(async (options) => {
+    const sourcesFolder = options.sourcesFolder;
+    const resourcesFolder = options.resourcesFolder;
+    const bundleFile = options.bundleFile;
+    const enterprisePackageFile = options.enterprisePackageFile;
+    const simulations = await (0, simulations_1.findSimulations)(sourcesFolder);
+    const typescript = typescriptWithDefaults(options, simulations);
+    await (0, bundle_1.bundle)({ sourcesFolder, bundleFile, typescript, simulations });
+    await (0, enterprisePackage_1.enterprisePackage)({ bundleFile, resourcesFolder, enterprisePackageFile, simulations });
 });
 program.parse(process.argv);

package/target/run.d.ts

@@ -1,9 +1,17 @@
 export interface RunOptions {
     graalvmHome: string;
     jvmClasspath: string;
+}
+export interface RunSimulationOptions extends RunOptions {
     simulation: string;
     bundleFile: string;
     resourcesFolder: string;
     resultsFolder: string;
 }
-export declare const run: (options: RunOptions) => Promise<void>;
+export interface RunRecorderOptions extends RunOptions {
+    sourcesFolder: string;
+    typescript: boolean;
+    resourcesFolder: string;
+}
+export declare const runSimulation: (options: RunSimulationOptions) => Promise<void>;
+export declare const runRecorder: (options: RunRecorderOptions) => Promise<void>;

package/target/run.js

@@ -1,27 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.run = void 0;
+exports.runRecorder = exports.runSimulation = void 0;
 const child_process_1 = require("child_process");
 const log_1 = require("./log");
 const versions_1 = require("./dependencies/versions");
 const os_1 = require("./dependencies/os");
-const run = async (options) => {
+const runSimulation = async (options) => {
     log_1.logger.info(`Running a Gatling simulation with options:
  - simulation: ${options.simulation}
- - bundleFile: ${options.bundleFile}`);
-    const command = `${options.graalvmHome}/bin/java`;
-    const classpathSeparator = os_1.osType === "Windows_NT" ? ";" : ":";
-    const args = [
-        "-server",
-        "-XX:+HeapDumpOnOutOfMemoryError",
-        "-XX:MaxInlineLevel=20",
-        "-XX:MaxTrivialSize=12",
-        "-Xmx1G",
-        "-classpath",
-        `${options.resourcesFolder}${classpathSeparator}${options.jvmClasspath}`,
+ - bundleFile: ${options.bundleFile}
+ - resourcesFolder: ${options.resourcesFolder}
+ - resultsFolder: ${options.resultsFolder}`);
+    const additionalClasspathElements = [options.resourcesFolder];
+    const javaArgs = [
         `-Dgatling.js.bundle.filePath=${options.bundleFile}`,
-        `-Dgatling.js.simulation=${options.simulation}`,
-        "io.gatling.app.Gatling",
+        `-Dgatling.js.simulation=${options.simulation}`
+    ];
+    const simulationArgs = [
         "--results-folder",
         options.resultsFolder,
         "--simulation",
@@ -31,7 +26,42 @@ const run = async (options) => {
         "--build-tool-version",
         versions_1.versions.gatling.jsAdapter
     ];
-    const process = (0, child_process_1.spawn)(command, args);
+    return run(options, "io.gatling.app.Gatling", additionalClasspathElements, javaArgs, simulationArgs);
+};
+exports.runSimulation = runSimulation;
+const runRecorder = async (options) => {
+    log_1.logger.info(`Running the Gatling Recorder with options:
+ - sourcesFolder: ${options.sourcesFolder}
+ - resourcesFolder: ${options.resourcesFolder}
+ - typescript: ${options.typescript}`);
+    const recorderArgs = [
+        "--simulations-folder",
+        options.sourcesFolder,
+        "--resources-folder",
+        options.resourcesFolder,
+        "--format",
+        options.typescript ? "typescript" : "javascript"
+    ];
+    return run(options, "io.gatling.recorder.GatlingRecorder", [], [], recorderArgs);
+};
+exports.runRecorder = runRecorder;
+const run = (options, mainClass, additionalClasspathElements, javaArgs, mainClassArgs) => {
+    const command = `${options.graalvmHome}/bin/java`;
+    const classpathSeparator = os_1.osType === "Windows_NT" ? ";" : ":";
+    const classpath = [...additionalClasspathElements, options.jvmClasspath].join(classpathSeparator);
+    const allArgs = [
+        "-server",
+        "-XX:+HeapDumpOnOutOfMemoryError",
+        "-XX:MaxInlineLevel=20",
+        "-XX:MaxTrivialSize=12",
+        "-Xmx1G",
+        "-classpath",
+        classpath,
+        ...javaArgs,
+        mainClass,
+        ...mainClassArgs
+    ];
+    const process = (0, child_process_1.spawn)(command, allArgs);
     return new Promise((resolve, reject) => {
         process.stdout.on("data", (data) => log_1.logger.info(data.toString()));
         process.stderr.on("data", (data) => log_1.logger.error(data.toString()));
@@ -46,4 +76,3 @@ const run = async (options) => {
         });
     });
 };
-exports.run = run;

package/target/simulations.d.ts

@@ -0,0 +1,6 @@
+export interface SimulationFile {
+    path: string;
+    name: string;
+    type: "javascript" | "typescript";
+}
+export declare const findSimulations: (sourcesFolder: string) => Promise<Array<SimulationFile>>;

package/target/simulations.js

@@ -0,0 +1,23 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findSimulations = void 0;
+const promises_1 = __importDefault(require("fs/promises"));
+const findSimulations = async (sourcesFolder) => {
+    const children = await promises_1.default.readdir(sourcesFolder, { recursive: false });
+    const simulations = children
+        .filter((path) => path.endsWith(".gatling.js") || path.endsWith(".gatling.ts"))
+        .map((path) => ({
+        path,
+        name: path.slice(0, -11),
+        type: path.endsWith(".ts") ? "typescript" : "javascript"
+    }));
+    const duplicates = simulations.filter((value, index) => simulations.findIndex((other) => other.name === value.name) !== index);
+    if (duplicates.length > 0) {
+        throw Error(`Found ambiguous simulation name(s) ${duplicates.map((s) => s.name)}: found as both *.gatling.js and *.gatling.ts file(s)`);
+    }
+    return simulations;
+};
+exports.findSimulations = findSimulations;