@gatling.io/cli 3.11.4 → 3.11.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gatling.io/cli",
-  "version": "3.11.4",
+  "version": "3.11.6",
   "license": "Apache-2.0",
   "bin": {
     "gatling": "target/index.js"
@@ -9,23 +9,26 @@
   "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",
-    "rimraf": "5.0.7",
-    "typescript": "5.4.5"
+    "@types/node": "20.14.12",
+    "@types/readline-sync": "1.4.8",
+    "prettier": "3.3.3",
+    "rimraf": "6.0.1",
+    "typescript": "5.5.3"
   },
   "scripts": {
     "clean": "rimraf target",
     "format": "prettier --write '**/*.ts'",
+    "format-check": "prettier --check '**/*.ts'",
     "build": "tsc -p . && chmod +x ./target/index.js"
   }
 }

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

@@ -3,12 +3,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.versions = void 0;
 exports.versions = {
     graalvm: {
-        jdk: "22.0.1",
-        js: "24.0.1"
+        jdk: "22.0.2",
+        js: "24.0.2"
     },
     coursier: "2.1.10",
     gatling: {
-        core: "3.11.4",
-        jsAdapter: "3.11.4"
+        core: "3.11.5",
+        enterprisePluginCommons: "1.9.6",
+        jsAdapter: "3.11.6"
     }
 };

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/enterprise.js

@@ -0,0 +1,174 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+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}
+ - packageFile: ${options.packageFile}`);
+    const manifest = generateManifest(options.simulations.map((s) => s.name));
+    const output = fs_1.default.createWriteStream(options.packageFile);
+    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.packageFile}`);
+};
+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",
+        "Specification-Vendor: GatlingCorp",
+        "Gatling-Context: js",
+        `Gatling-Version: ${versions_1.versions.gatling.core}`,
+        "Gatling-Packager: js-cli",
+        `Gatling-Packager-Version: ${versions_1.versions.gatling.jsAdapter}`,
+        `Gatling-Simulations: ${simulationNames.join(",")}`,
+        `Java-Version: ${versions_1.versions.graalvm.jdk.split(".")[0]}`
+    ];
+    const pkg = getPackageNameAndVersion();
+    lines.push(`Implementation-Title: ${pkg.name}`);
+    if (pkg.version !== undefined) {
+        lines.push(`Implementation-Version: ${pkg.version}`);
+    }
+    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;
+};
+const getPackageNameAndVersion = () => {
+    // npm_package_* env vars are available when launching CLI with npx
+    let name = process.env.npm_package_name;
+    let version = process.env.npm_package_version;
+    // otherwise, try to read from package.json file
+    if (name === undefined || version === undefined) {
+        if (!fs_1.default.existsSync("package.json")) {
+            throw Error("package.json not found");
+        }
+        const pkg = JSON.parse(fs_1.default.readFileSync("package.json", "utf-8"));
+        if (name === undefined) {
+            if (typeof pkg.name === "string") {
+                name = pkg.name;
+            }
+            else {
+                throw Error("package.json does not contain a valid package name");
+            }
+        }
+        if (version === undefined && typeof pkg.version === "string") {
+            version = pkg.version;
+        }
+    }
+    return { name: name, version: version };
+};
+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}`);
+    javaArgs.push(`-Dgatling.enterprise.artifactId=${getPackageNameAndVersion().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>;

package/target/enterprisePackage.js

@@ -1,82 +0,0 @@
-"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;
-};