@gatling.io/cli 3.11.4 → 3.11.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gatling.io/cli",
-  "version": "3.11.4",
+  "version": "3.11.5",
   "license": "Apache-2.0",
   "bin": {
     "gatling": "target/index.js"
@@ -9,17 +9,19 @@
   "types": "target/index.d.ts",
   "dependencies": {
     "archiver": "7.0.1",
-    "axios": "1.6.8",
-    "commander": "12.0.0",
+    "axios": "1.7.2",
+    "commander": "12.1.0",
     "decompress": "4.2.1",
-    "esbuild": "0.21.2",
-    "esbuild-plugin-tsc": "0.4.0"
+    "esbuild": "0.23.0",
+    "esbuild-plugin-tsc": "0.4.0",
+    "readline-sync": "1.4.10"
   },
   "devDependencies": {
     "@types/archiver": "6.0.2",
     "@types/decompress": "4.2.7",
-    "@types/node": "20.12.12",
-    "prettier": "3.2.5",
+    "@types/node": "20.14.9",
+    "@types/readline-sync": "1.4.8",
+    "prettier": "3.3.2",
     "rimraf": "5.0.7",
     "typescript": "5.4.5"
   },

package/target/dependencies/coursier.js

@@ -49,8 +49,9 @@ exports.installCoursier = installCoursier;
 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 gatlingEnterprisePluginCommonsDep = `"io.gatling:gatling-enterprise-plugin-commons:${versions_1.versions.gatling.enterprisePluginCommons}"`;
     const graalvmJsDep = `"org.graalvm.polyglot:js-community:${versions_1.versions.graalvm.js}"`;
-    return await resolveDependencies(coursierPath, javaHome, gatlingDep, gatlingAdapterDep, graalvmJsDep);
+    return await resolveDependencies(coursierPath, javaHome, gatlingDep, gatlingAdapterDep, gatlingEnterprisePluginCommonsDep, graalvmJsDep);
 };
 exports.resolveGatlingJsDependencies = resolveGatlingJsDependencies;
 const resolveRecorderDependencies = async (coursierPath, javaHome) => {

package/target/dependencies/versions.d.ts

@@ -6,6 +6,7 @@ export declare const versions: {
     coursier: string;
     gatling: {
         core: string;
+        enterprisePluginCommons: string;
         jsAdapter: string;
     };
 };

package/target/dependencies/versions.js

@@ -8,7 +8,8 @@ exports.versions = {
     },
     coursier: "2.1.10",
     gatling: {
-        core: "3.11.4",
-        jsAdapter: "3.11.4"
+        core: "3.11.5",
+        enterprisePluginCommons: "1.9.4",
+        jsAdapter: "3.11.5"
     }
 };

package/target/enterprise.d.ts

@@ -0,0 +1,30 @@
+import { RunJavaProcessOptions } from "./java";
+import { SimulationFile } from "./simulations";
+export interface EnterprisePackageOptions {
+    bundleFile: string;
+    resourcesFolder: string;
+    packageFile: string;
+    simulations: SimulationFile[];
+}
+export declare const enterprisePackage: (options: EnterprisePackageOptions) => Promise<void>;
+export interface EnterprisePluginOptions extends RunJavaProcessOptions {
+    bundleFile: string;
+    resourcesFolder: string;
+    resultsFolder: string;
+    url: string;
+    apiToken?: string;
+    controlPlaneUrl?: string;
+    nonInteractive: boolean;
+}
+export interface EnterpriseDeployOptions extends EnterprisePluginOptions {
+    packageDescriptorFilename: string;
+    packageFile: string;
+}
+export declare const enterpriseDeploy: (options: EnterpriseDeployOptions) => Promise<void>;
+export interface EnterpriseStartOptions extends EnterpriseDeployOptions {
+    enterpriseSimulation?: string;
+    runTitle?: string;
+    runDescription?: string;
+    waitForRunEnd?: boolean;
+}
+export declare const enterpriseStart: (options: EnterpriseStartOptions) => Promise<void>;

package/target/{enterprisePackage.js → enterprise.js}

@@ -3,19 +3,20 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.enterprisePackage = void 0;
+exports.enterpriseStart = exports.enterpriseDeploy = 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 java_1 = require("./java");
 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}`);
+ - packageFile: ${options.packageFile}`);
     const manifest = generateManifest(options.simulations.map((s) => s.name));
-    const output = fs_1.default.createWriteStream(options.enterprisePackageFile);
+    const output = fs_1.default.createWriteStream(options.packageFile);
     const archive = (0, archiver_1.default)("zip", {
         zlib: { level: zlib_1.constants.Z_MAX_LEVEL }
     });
@@ -29,7 +30,7 @@ const enterprisePackage = async (options) => {
     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}`);
+    log_1.logger.info(`Package for Gatling Enterprise created at ${options.packageFile}`);
 };
 exports.enterprisePackage = enterprisePackage;
 const generateManifest = (simulationNames) => {
@@ -80,3 +81,70 @@ const generateManifest = (simulationNames) => {
     }
     return manifest;
 };
+const javaArgsFromPluginOptions = (options) => {
+    const javaArgs = [];
+    // Base
+    javaArgs.push(`-Dgatling.enterprise.url=${options.url}`);
+    if (options.apiToken !== undefined) {
+        javaArgs.push(`-Dgatling.enterprise.apiToken=${options.apiToken}`);
+    }
+    // Plugin configuration
+    if (options.controlPlaneUrl !== undefined) {
+        javaArgs.push(`-Dgatling.enterprise.controlPlaneUrl=${options.controlPlaneUrl}`);
+    }
+    javaArgs.push("-Dgatling.enterprise.buildTool=JS_CLI");
+    javaArgs.push(`-Dgatling.enterprise.pluginVersion=${versions_1.versions.gatling.jsAdapter}`);
+    if (options.nonInteractive) {
+        javaArgs.push(`-Dgatling.enterprise.batchMode=true`);
+    }
+    return javaArgs;
+};
+const javaArgsFromDeployOptions = (options) => {
+    const javaArgs = javaArgsFromPluginOptions(options);
+    // Descriptor file
+    javaArgs.push(`-Dgatling.enterprise.baseDirectory=${process.cwd()}`);
+    javaArgs.push(`-Dgatling.enterprise.packageDescriptorFilename=${options.packageDescriptorFilename}`);
+    // Deployment info
+    javaArgs.push(`-Dgatling.enterprise.packageFile=${options.packageFile}`);
+    if (process.env.npm_package_name !== undefined) {
+        javaArgs.push(`-Dgatling.enterprise.artifactId=${process.env.npm_package_name}`);
+    }
+    return javaArgs;
+};
+const enterpriseDeploy = async (options) => {
+    const additionalClasspathElements = [options.resourcesFolder];
+    const javaArgs = javaArgsFromDeployOptions(options);
+    if (process.env["DEBUG"] === "true") {
+        log_1.logger.debug("Java arguments:");
+        for (let i = 0; i < javaArgs.length; i++) {
+            log_1.logger.debug("  " + javaArgs[i]);
+        }
+    }
+    return (0, java_1.runJavaProcess)(options, "io.gatling.plugin.cli.EnterpriseDeploy", additionalClasspathElements, javaArgs, []);
+};
+exports.enterpriseDeploy = enterpriseDeploy;
+const enterpriseStart = async (options) => {
+    const additionalClasspathElements = [options.resourcesFolder];
+    const javaArgs = javaArgsFromDeployOptions(options);
+    // Start
+    if (options.enterpriseSimulation !== undefined) {
+        javaArgs.push(`-Dgatling.enterprise.simulationName=${options.enterpriseSimulation}`);
+    }
+    if (options.runTitle !== undefined) {
+        javaArgs.push(`-Dgatling.enterprise.runTitle=${options.runTitle}`);
+    }
+    if (options.runDescription !== undefined) {
+        javaArgs.push(`-Dgatling.enterprise.runDescription=${options.runDescription}`);
+    }
+    if (options.waitForRunEnd) {
+        javaArgs.push("-Dgatling.enterprise.waitForRunEnd=true");
+    }
+    if (process.env["DEBUG"] === "true") {
+        log_1.logger.debug("Java arguments:");
+        for (let i = 0; i < javaArgs.length; i++) {
+            log_1.logger.debug("  " + javaArgs[i]);
+        }
+    }
+    return (0, java_1.runJavaProcess)(options, "io.gatling.plugin.cli.EnterpriseStart", additionalClasspathElements, javaArgs, []);
+};
+exports.enterpriseStart = enterpriseStart;

package/target/index.js

@@ -8,9 +8,10 @@ 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 enterprise_1 = require("./enterprise");
 const simulations_1 = require("./simulations");
 const log_1 = require("./log");
+const readline_1 = require("./readline");
 const run_1 = require("./run");
 const program = new commander_1.Command()
     .name("gatling-js-cli")
@@ -20,7 +21,7 @@ const gatlingHomeOption = new commander_1.Option("--gatling-home <value>", 'The
 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: if only one *.gatling.js or *.gatling.ts file is found, will execute that simulation)");
-const simulationWithDefaults = (options, simulationsFound) => {
+const simulationWithDefaults = (options, simulationsFound, interactive) => {
     if (options.simulation !== undefined) {
         return options.simulation;
     }
@@ -30,6 +31,17 @@ const simulationWithDefaults = (options, simulationsFound) => {
     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 if (interactive) {
+        const idx = (0, readline_1.keyInSelectPaginated)(simulationsFound.map((s) => s.name).sort((a, b) => a.localeCompare(b)), "Choose a simulation to run");
+        if (idx >= 0) {
+            const simulation = simulationsFound[idx].name;
+            log_1.logger.info(`Simulation '${simulation}' was chosen.`);
+            return simulation;
+        }
+        else {
+            throw new Error("Simulation choice was cancelled.");
+        }
+    }
     else {
         throw new Error(`Several simulations found, specify one using the --simulation option (available simulations: ${simulationsFound.map((s) => s.name)})`);
     }
@@ -42,12 +54,12 @@ const validateBundleFile = (options) => {
     }
     return options.bundleFile;
 };
-const enterprisePackageFileOption = new commander_1.Option("--enterprise-package-file <value>", "The target package file path when packaging simulations for Gatling Enterprise (must have a .zip extension)").default("target/package.zip");
-const validateEnterprisePackageFile = (options) => {
-    if (!options.enterprisePackageFile.endsWith(".zip")) {
-        throw Error(`'${options.enterprisePackageFile}' is not a valid package file path: should have a .zip extension`);
+const packageFileOption = new commander_1.Option("--package-file <value>", "The target package file path when packaging simulations for Gatling Enterprise (must have a .zip extension)").default("target/package.zip");
+const validatePackageFile = (options) => {
+    if (!options.packageFile.endsWith(".zip")) {
+        throw Error(`'${options.packageFile}' is not a valid package file path: should have a .zip extension`);
     }
-    return options.enterprisePackageFile;
+    return options.packageFile;
 };
 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");
@@ -57,6 +69,29 @@ const typescriptWithDefaults = (options, simulationsFound) => 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);
+const memoryOption = new commander_1.Option("--memory <value>", "Heap space memory size in MiB for Gatling. Half the total available memory is usually a good default, as the Gatling process will use more memory than just the heap space.").argParser((value) => {
+    const parsedValue = parseInt(value, 10);
+    if (isNaN(parsedValue)) {
+        throw new Error(`${value} is not a valid memory size, must be an integer number`);
+    }
+    return parsedValue;
+});
+const nonInteractiveOption = new commander_1.Option("--non-interactive", "Switch to non-interactive mode and fail if no simulation is explicitly specified").default(false);
+const runOptionsArgument = new commander_1.Argument("[optionKey=optionValue...]", "Specify one or more option which can be read in the simulation script with the getOption() function; format must be key=value");
+const parseRunOptions = (args) => {
+    const parsedOptions = {};
+    for (const arg of args) {
+        const i = arg.indexOf("=");
+        if (i < 0) {
+            throw Error(`Option '${arg}' is not valid: format should be key=value`);
+        }
+        else {
+            const key = arg.slice(0, i).trim();
+            parsedOptions[key] = arg.slice(i + 1);
+        }
+    }
+    return parsedOptions;
+};
 program
     .command("install")
     .description("Install all required components and dependencies for Gatling")
@@ -90,20 +125,26 @@ program
     .addOption(bundleFileOption)
     .addOption(resourcesFolderOption)
     .addOption(resultsFolderOption)
-    .action(async (options) => {
+    .addOption(memoryOption)
+    .addArgument(runOptionsArgument)
+    .action(async (args, options) => {
     const graalvmHome = options.graalvmHome;
     const jvmClasspath = options.jvmClasspath;
     const simulation = options.simulation;
     const bundleFile = validateBundleFile(options);
     const resourcesFolder = options.resourcesFolder;
     const resultsFolder = options.resultsFolder;
+    const memory = options.memory;
+    const runOptions = parseRunOptions(args);
     await (0, run_1.runSimulation)({
         graalvmHome,
         jvmClasspath,
         simulation: simulation,
         bundleFile,
         resourcesFolder,
-        resultsFolder
+        resultsFolder,
+        memory,
+        runOptions
     });
 });
 program
@@ -116,21 +157,36 @@ program
     .addOption(resourcesFolderOption)
     .addOption(resultsFolderOption)
     .addOption(gatlingHomeOption)
-    .action(async (options) => {
+    .addOption(memoryOption)
+    .addOption(nonInteractiveOption)
+    .addArgument(runOptionsArgument)
+    .action(async (args, options) => {
     const gatlingHome = gatlingHomeDirWithDefaults(options);
     const sourcesFolder = options.sourcesFolder;
     const bundleFile = validateBundleFile(options);
     const resourcesFolder = options.resourcesFolder;
     const resultsFolder = options.resultsFolder;
+    const memory = options.memory;
+    const nonInteractive = options.nonInteractive;
+    const runOptions = parseRunOptions(args);
     const simulations = await (0, simulations_1.findSimulations)(sourcesFolder);
     const typescript = typescriptWithDefaults(options, simulations);
-    const simulation = simulationWithDefaults(options, simulations);
+    const simulation = simulationWithDefaults(options, simulations, !nonInteractive);
     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 });
+    await (0, run_1.runSimulation)({
+        graalvmHome,
+        jvmClasspath,
+        simulation,
+        bundleFile,
+        resourcesFolder,
+        resultsFolder,
+        memory,
+        runOptions
+    });
 });
 program
     .command("recorder")
@@ -157,16 +213,128 @@ program
     .addOption(sourcesFolderOption)
     .addOption(resourcesFolderOption)
     .addOption(bundleFileOption)
-    .addOption(enterprisePackageFileOption)
+    .addOption(packageFileOption)
     .addOption(typescriptOption)
     .action(async (options) => {
     const sourcesFolder = options.sourcesFolder;
     const resourcesFolder = options.resourcesFolder;
     const bundleFile = validateBundleFile(options);
-    const enterprisePackageFile = validateEnterprisePackageFile(options);
+    const packageFile = validatePackageFile(options);
     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 });
+    await (0, enterprise_1.enterprisePackage)({ bundleFile, resourcesFolder, packageFile, simulations });
+});
+const urlOption = new commander_1.Option("--url <value>", "URL of Gatling Enterprise")
+    .default("https://cloud.gatling.io")
+    .hideHelp();
+const apiTokenOption = new commander_1.Option("--api-token <value>", "API Token on Gatling Enterprise. Prefer configuration using `GATLING_ENTERPRISE_API_TOKEN` environment variable.");
+// Plugin configuration
+const controlPlaneUrlOption = new commander_1.Option("--control-plane-url <value>", "URL of a control plane for Gatling Enterprise providing a private repository. If this parameter is provided, packages will be registered as private packages and uploaded through this private control plane.");
+// Descriptor file
+const packageDescriptorFilenameOption = new commander_1.Option("--package-descriptor-filename <value>", "Path to a package descriptor inside the .gatling folder").default("package.conf");
+const enterpriseBundleAndPackage = async (options) => {
+    const gatlingHome = gatlingHomeDirWithDefaults(options);
+    const sourcesFolder = options.sourcesFolder;
+    const bundleFile = validateBundleFile(options);
+    const resourcesFolder = options.resourcesFolder;
+    const resultsFolder = options.resultsFolder;
+    const simulations = await (0, simulations_1.findSimulations)(sourcesFolder);
+    const typescript = typescriptWithDefaults(options, simulations);
+    // Base
+    const url = options.url;
+    const apiToken = options.apiToken;
+    // Plugin configuration
+    const controlPlaneUrl = options.controlPlaneUrl;
+    const nonInteractive = options.nonInteractive;
+    // Descriptor file
+    const packageDescriptorFilename = options.packageDescriptorFilename;
+    // Deployment info
+    const packageFile = validatePackageFile(options);
+    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, enterprise_1.enterprisePackage)({ bundleFile, resourcesFolder, packageFile, simulations });
+    return {
+        graalvmHome,
+        jvmClasspath,
+        bundleFile,
+        resourcesFolder,
+        resultsFolder,
+        // Base
+        url,
+        apiToken,
+        // Plugin configuration
+        controlPlaneUrl,
+        nonInteractive,
+        // Descriptor file
+        packageDescriptorFilename,
+        // Deployment info
+        packageFile
+    };
+};
+program
+    .command("enterprise-deploy")
+    .description("Deploy a package and configured simulations")
+    .addOption(sourcesFolderOption)
+    .addOption(resourcesFolderOption)
+    .addOption(bundleFileOption)
+    .addOption(resultsFolderOption)
+    // Base
+    .addOption(urlOption)
+    .addOption(apiTokenOption)
+    // Plugin configuration
+    .addOption(controlPlaneUrlOption)
+    .addOption(nonInteractiveOption)
+    // Descriptor file
+    .addOption(packageDescriptorFilenameOption)
+    // Deployment info
+    .addOption(packageFileOption)
+    .action(async (options) => {
+    const deployOptions = await enterpriseBundleAndPackage(options);
+    await (0, enterprise_1.enterpriseDeploy)(deployOptions);
+});
+// Deployment info
+const enterpriseSimulationOption = new commander_1.Option("--enterprise-simulation <value>", "Specify the simulation name directly to bypass the prompt using the following command.");
+const runTitleOption = new commander_1.Option("--run-title <value>", "Allows setting a title for your run reports.");
+const runDescriptionOption = new commander_1.Option("--run-description <value>", "Allows setting a description for your run reports summary.");
+const waitForRunEndOption = new commander_1.Option("--wait-for-run-end", "Wait for the result after starting the simulation on Gatling Enterprise, and complete with an error if the simulation ends with any error status").default(false);
+program
+    .command("enterprise-start")
+    .description("Start a simulation deployed with `enterprise-deploy`")
+    .addOption(sourcesFolderOption)
+    .addOption(resourcesFolderOption)
+    .addOption(bundleFileOption)
+    .addOption(resultsFolderOption)
+    // Base
+    .addOption(urlOption)
+    .addOption(apiTokenOption)
+    // Plugin configuration
+    .addOption(controlPlaneUrlOption)
+    .addOption(nonInteractiveOption)
+    // Descriptor file
+    .addOption(packageDescriptorFilenameOption)
+    // Deployment info
+    .addOption(packageFileOption)
+    // Start
+    .addOption(enterpriseSimulationOption)
+    .addOption(runTitleOption)
+    .addOption(runDescriptionOption)
+    .addOption(waitForRunEndOption)
+    .action(async (options) => {
+    const deployOptions = await enterpriseBundleAndPackage(options);
+    if (options.nonInteractive && options.enterpriseSimulation === undefined) {
+        throw new Error(`No simulation specified when using non-interactive mode`);
+    }
+    await (0, enterprise_1.enterpriseStart)({
+        ...deployOptions,
+        // Start
+        enterpriseSimulation: options.enterpriseSimulation,
+        runTitle: options.runTitle,
+        runDescription: options.runDescription,
+        waitForRunEnd: options.waitForRunEnd
+    });
 });
 program.parse(process.argv);

package/target/java.d.ts

@@ -0,0 +1,5 @@
+export interface RunJavaProcessOptions {
+    graalvmHome: string;
+    jvmClasspath: string;
+}
+export declare const runJavaProcess: (options: RunJavaProcessOptions, mainClass: string, additionalClasspathElements: string[], javaArgs: string[], mainClassArgs: string[]) => Promise<void>;

package/target/java.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runJavaProcess = void 0;
+const child_process_1 = require("child_process");
+const os_1 = require("./dependencies/os");
+const log_1 = require("./log");
+const runJavaProcess = (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",
+        "-classpath",
+        classpath,
+        ...javaArgs,
+        mainClass,
+        ...mainClassArgs
+    ];
+    const spawned = (0, child_process_1.spawn)(command, allArgs, {
+        env: process.env,
+        stdio: [process.stdin, process.stdout, process.stderr]
+    });
+    return new Promise((resolve, reject) => {
+        spawned.on("error", (error) => log_1.logger.error("Failed to run Gatling process: " + error.toString()));
+        spawned.on("close", (code) => {
+            if (code === 0) {
+                resolve();
+            }
+            else {
+                reject(Error("Gatling process finished with code " + code));
+            }
+        });
+    });
+};
+exports.runJavaProcess = runJavaProcess;

package/target/readline.d.ts

@@ -0,0 +1,2 @@
+import { BasicOptions } from "readline-sync";
+export declare const keyInSelectPaginated: (items: string[], query?: any, options?: BasicOptions | undefined) => number;

package/target/readline.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.keyInSelectPaginated = void 0;
+const readline_sync_1 = require("readline-sync");
+// Inspired by https://github.com/anseki/readline-sync/issues/60#issuecomment-324533678
+// Pagination avoids very long lists to scroll though, as well as the hard limit at 35 items for keyInSelect
+const keyInSelectPaginated = (items, query, options) => {
+    if (items.length === 0) {
+        return -1;
+    }
+    const maxItemsPerPage = 10;
+    const maxPageIndex = Math.ceil(items.length / maxItemsPerPage) - 1;
+    let pageIndex = 0;
+    while (true) {
+        const pageItems = [];
+        let indexPrev = -1;
+        let indexNext = -1;
+        if (pageIndex > 0) {
+            pageItems.push(`(PREVIOUS ${maxItemsPerPage} items)`);
+            indexPrev = pageItems.length - 1;
+        }
+        pageItems.push(...items.slice(pageIndex * maxItemsPerPage, (pageIndex + 1) * maxItemsPerPage));
+        if (pageIndex < maxPageIndex) {
+            pageItems.push(`(NEXT ${pageIndex < maxPageIndex - 1 ? maxItemsPerPage : items.length - maxItemsPerPage * (pageIndex + 1)} item(s))`);
+            indexNext = pageItems.length - 1;
+        }
+        console.log("\x1B[2J"); // clear screen
+        const index = (0, readline_sync_1.keyInSelect)(pageItems, query, options);
+        if (indexPrev !== -1 && index === indexPrev) {
+            pageIndex--;
+        }
+        else if (indexNext !== -1 && index === indexNext) {
+            pageIndex++;
+        }
+        else {
+            return index === -1 ? index : index + pageIndex * maxItemsPerPage - (indexPrev === -1 ? 0 : 1);
+        }
+    }
+};
+exports.keyInSelectPaginated = keyInSelectPaginated;

package/target/run.d.ts

@@ -1,14 +1,13 @@
-export interface RunOptions {
-    graalvmHome: string;
-    jvmClasspath: string;
-}
-export interface RunSimulationOptions extends RunOptions {
+import { RunJavaProcessOptions } from "./java";
+export interface RunSimulationOptions extends RunJavaProcessOptions {
     simulation: string;
     bundleFile: string;
     resourcesFolder: string;
     resultsFolder: string;
+    memory?: number;
+    runOptions: Record<string, string>;
 }
-export interface RunRecorderOptions extends RunOptions {
+export interface RunRecorderOptions extends RunJavaProcessOptions {
     sourcesFolder: string;
     typescript: boolean;
     resourcesFolder: string;

package/target/run.js

@@ -1,10 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 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 java_1 = require("./java");
 const runSimulation = async (options) => {
     log_1.logger.info(`Running a Gatling simulation with options:
  - simulation: ${options.simulation}
@@ -12,9 +11,12 @@ const runSimulation = async (options) => {
  - resourcesFolder: ${options.resourcesFolder}
  - resultsFolder: ${options.resultsFolder}`);
     const additionalClasspathElements = [options.resourcesFolder];
+    const memoryArgs = options.memory !== undefined ? [`-Xms${options.memory}M`, `-Xmx${options.memory}M`] : [];
     const javaArgs = [
+        ...Object.entries(options.runOptions).map(([key, value]) => `-D${key}=${value}`),
         `-Dgatling.js.bundle.filePath=${options.bundleFile}`,
-        `-Dgatling.js.simulation=${options.simulation}`
+        `-Dgatling.js.simulation=${options.simulation}`,
+        ...memoryArgs
     ];
     const simulationArgs = [
         "--results-folder",
@@ -26,7 +28,7 @@ const runSimulation = async (options) => {
         "--build-tool-version",
         versions_1.versions.gatling.jsAdapter
     ];
-    return run(options, "io.gatling.app.Gatling", additionalClasspathElements, javaArgs, simulationArgs);
+    return (0, java_1.runJavaProcess)(options, "io.gatling.app.Gatling", additionalClasspathElements, javaArgs, simulationArgs);
 };
 exports.runSimulation = runSimulation;
 const runRecorder = async (options) => {
@@ -42,37 +44,6 @@ const runRecorder = async (options) => {
         "--format",
         options.typescript ? "typescript" : "javascript"
     ];
-    return run(options, "io.gatling.recorder.GatlingRecorder", [], [], recorderArgs);
+    return (0, java_1.runJavaProcess)(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()));
-        process.on("error", (error) => log_1.logger.error("Failed to run Gatling process: " + error.toString()));
-        process.on("close", (code) => {
-            if (code === 0) {
-                resolve();
-            }
-            else {
-                reject(Error("Gatling process finished with code " + code));
-            }
-        });
-    });
-};

package/target/enterprisePackage.d.ts

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