@gatling.io/cli 3.11.7 → 3.12.0

package/src/commands/recorder.ts

@@ -0,0 +1,41 @@
+import { Command } from "commander";
+
+import {
+  gatlingHomeOption,
+  gatlingHomeOptionValueWithDefaults,
+  resourcesFolderOption,
+  resourcesFolderOptionValue,
+  sourcesFolderOption,
+  sourcesFolderOptionValue,
+  typescriptOption,
+  typescriptOptionValueWithDefaults
+} from "./options";
+import { findSimulations } from "../simulations";
+import { installRecorder } from "../dependencies";
+import { logger } from "../log";
+import { runRecorder } from "../run";
+
+export default (program: Command): void => {
+  program
+    .command("recorder")
+    .description("Run the Gatling recorder")
+    .addOption(gatlingHomeOption)
+    .addOption(sourcesFolderOption)
+    .addOption(typescriptOption)
+    .addOption(resourcesFolderOption)
+    .action(async (options) => {
+      const gatlingHome: string = gatlingHomeOptionValueWithDefaults(options);
+      const sourcesFolder: string = sourcesFolderOptionValue(options);
+      const resourcesFolder: string = resourcesFolderOptionValue(options);
+
+      const simulations = await findSimulations(sourcesFolder);
+      const typescript = typescriptOptionValueWithDefaults(options, simulations);
+
+      const { graalvmHome, coursierBinary, jvmClasspath } = await installRecorder({ gatlingHome });
+      logger.debug(`graalvmHome=${graalvmHome}`);
+      logger.debug(`coursierBinary=${coursierBinary}`);
+      logger.debug(`jvmClasspath=${jvmClasspath}`);
+
+      await runRecorder({ graalvmHome, jvmClasspath, sourcesFolder, typescript, resourcesFolder });
+    });
+};

package/src/commands/run.ts

@@ -0,0 +1,78 @@
+import { Command } from "commander";
+import {
+  bundleFileOption,
+  bundleFileOptionValue,
+  gatlingHomeOption,
+  gatlingHomeOptionValueWithDefaults,
+  memoryOption,
+  memoryOptionValue,
+  nonInteractiveOption,
+  nonInteractiveOptionValue,
+  parseRunParametersArgument,
+  resourcesFolderOption,
+  resourcesFolderOptionValue,
+  resultsFolderOption,
+  resultsFolderOptionValue,
+  runParametersArgument,
+  simulationOption,
+  simulationOptionValueWithDefaults,
+  sourcesFolderOption,
+  sourcesFolderOptionValue,
+  typescriptOption,
+  typescriptOptionValueWithDefaults
+} from "./options";
+import { findSimulations } from "../simulations";
+import { installGatlingJs } from "../dependencies";
+import { logger } from "../log";
+import { bundle } from "../bundle";
+import { runSimulation } from "../run";
+
+export default (program: Command): void => {
+  program
+    .command("run")
+    .description(
+      "Build and run a Gatling simulation, after installing all required components and dependencies for Gatling"
+    )
+    .addOption(sourcesFolderOption)
+    .addOption(simulationOption)
+    .addOption(typescriptOption)
+    .addOption(bundleFileOption)
+    .addOption(resourcesFolderOption)
+    .addOption(resultsFolderOption)
+    .addOption(gatlingHomeOption)
+    .addOption(memoryOption)
+    .addOption(nonInteractiveOption)
+    .addArgument(runParametersArgument)
+    .action(async (args: string[], options) => {
+      const gatlingHome = gatlingHomeOptionValueWithDefaults(options);
+      const sourcesFolder: string = sourcesFolderOptionValue(options);
+      const bundleFile = bundleFileOptionValue(options);
+      const resourcesFolder: string = resourcesFolderOptionValue(options);
+      const resultsFolder: string = resultsFolderOptionValue(options);
+      const memory: number | undefined = memoryOptionValue(options);
+      const nonInteractive: boolean = nonInteractiveOptionValue(options);
+      const runParameters = parseRunParametersArgument(args);
+
+      const simulations = await findSimulations(sourcesFolder);
+      const typescript = typescriptOptionValueWithDefaults(options, simulations);
+      const simulation = simulationOptionValueWithDefaults(options, simulations, !nonInteractive);
+
+      const { graalvmHome, coursierBinary, jvmClasspath } = await installGatlingJs({ gatlingHome });
+      logger.debug(`graalvmHome=${graalvmHome}`);
+      logger.debug(`coursierBinary=${coursierBinary}`);
+      logger.debug(`jvmClasspath=${jvmClasspath}`);
+
+      await bundle({ sourcesFolder, bundleFile, typescript, simulations });
+
+      await runSimulation({
+        graalvmHome,
+        jvmClasspath,
+        simulation,
+        bundleFile,
+        resourcesFolder,
+        resultsFolder,
+        memory,
+        runParameters
+      });
+    });
+};

package/src/commands/runOnly.ts

@@ -0,0 +1,56 @@
+import { Command } from "commander";
+
+import {
+  bundleFileOption,
+  bundleFileOptionValue,
+  graalvmHomeMandatoryOption,
+  graalvmHomeMandatoryOptionValue,
+  jvmClasspathMandatoryOption,
+  jvmClasspathMandatoryOptionValue,
+  memoryOption,
+  memoryOptionValue,
+  parseRunParametersArgument,
+  resourcesFolderOption,
+  resourcesFolderOptionValue,
+  resultsFolderOption,
+  resultsFolderOptionValue,
+  runParametersArgument,
+  simulationMandatoryOption,
+  simulationMandatoryOptionValue
+} from "./options";
+import { runSimulation } from "../run";
+
+export default (program: Command): void => {
+  program
+    .command("run-only")
+    .description("Run a Gatling simulation from an already built bundle")
+    .addOption(graalvmHomeMandatoryOption)
+    .addOption(jvmClasspathMandatoryOption)
+    .addOption(simulationMandatoryOption)
+    .addOption(bundleFileOption)
+    .addOption(resourcesFolderOption)
+    .addOption(resultsFolderOption)
+    .addOption(memoryOption)
+    .addArgument(runParametersArgument)
+    .action(async (args: string[], options) => {
+      const graalvmHome: string = graalvmHomeMandatoryOptionValue(options);
+      const jvmClasspath: string = jvmClasspathMandatoryOptionValue(options);
+      const simulation: string = simulationMandatoryOptionValue(options);
+      const bundleFile = bundleFileOptionValue(options);
+      const resourcesFolder: string = resourcesFolderOptionValue(options);
+      const resultsFolder: string = resultsFolderOptionValue(options);
+      const memory: number | undefined = memoryOptionValue(options);
+      const runParameters = parseRunParametersArgument(args);
+
+      await runSimulation({
+        graalvmHome,
+        jvmClasspath,
+        simulation: simulation,
+        bundleFile,
+        resourcesFolder,
+        resultsFolder,
+        memory,
+        runParameters
+      });
+    });
+};

package/src/dependencies/coursier.ts

@@ -0,0 +1,82 @@
+import { existsSync } from "fs";
+import fs from "fs/promises";
+
+import { downloadFile } from "./download";
+import { logger } from "../log";
+import { versions } from "./versions";
+import { promisify } from "util";
+import { exec } from "child_process";
+import { osType } from "./os";
+
+export const installCoursier = async (gatlingHomeDir: string, downloadDir: string): Promise<string> => {
+  const coursierRootPath = `${gatlingHomeDir}/coursier/${versions.coursier}`;
+  const coursierPath = `${coursierRootPath}/cs`;
+
+  if (!existsSync(coursierPath)) {
+    const jarUrl = `https://github.com/coursier/coursier/releases/download/v${versions.coursier}/coursier`;
+    const windowsBatUrl = `https://github.com/coursier/launchers/raw/master/coursier.bat`;
+    const downloadPath = `${downloadDir}/cs`;
+
+    if (existsSync(coursierRootPath)) {
+      await fs.rm(coursierRootPath, { recursive: true });
+    }
+    if (existsSync(downloadPath)) {
+      await fs.rm(downloadPath);
+    }
+    await fs.mkdir(coursierRootPath, { recursive: true });
+
+    logger.info(`Downloading Coursier ${versions.coursier} to ${downloadPath}`);
+    await downloadFile(jarUrl, downloadPath);
+    if (osType === "Windows_NT") {
+      await downloadFile(windowsBatUrl, `${downloadPath}.bat`);
+    } else {
+      await fs.chmod(downloadPath, 0o744);
+    }
+
+    logger.info(`Installing Coursier to ${coursierPath}`);
+    await fs.rename(downloadPath, coursierPath);
+    if (osType === "Windows_NT") {
+      await fs.rename(`${downloadPath}.bat`, `${coursierPath}.bat`);
+    }
+  } else {
+    logger.info(`Coursier ${versions.coursier} already installed at ${coursierPath}`);
+  }
+
+  return coursierPath;
+};
+
+export const resolveGatlingJsDependencies = async (coursierPath: string, javaHome: string): Promise<string> => {
+  const gatlingDep = `"io.gatling.highcharts:gatling-charts-highcharts:${versions.gatling.core}"`;
+  const gatlingAdapterDep = `"io.gatling:gatling-jvm-to-js-adapter:${versions.gatling.jsAdapter}"`;
+  const gatlingEnterprisePluginCommonsDep = `"io.gatling:gatling-enterprise-plugin-commons:${versions.gatling.enterprisePluginCommons}"`;
+  const graalvmJsDep = `"org.graalvm.polyglot:js-community:${versions.graalvm.js}"`;
+
+  return await resolveDependencies(
+    coursierPath,
+    javaHome,
+    gatlingDep,
+    gatlingAdapterDep,
+    gatlingEnterprisePluginCommonsDep,
+    graalvmJsDep
+  );
+};
+
+export const resolveRecorderDependencies = async (coursierPath: string, javaHome: string): Promise<string> => {
+  const recorderDep = `io.gatling:gatling-recorder:${versions.gatling.core}`;
+  return await resolveDependencies(coursierPath, javaHome, recorderDep);
+};
+
+const resolveDependencies = async (
+  coursierPath: string,
+  javaHome: string,
+  ...dependencies: string[]
+): Promise<string> => {
+  const command = `"${coursierPath}" fetch --classpath ${dependencies.join(" ")}`;
+
+  // TODO could add a timeout
+  logger.info(`Resolving dependencies with Coursier`);
+  const { stdout } = await execAsync(command, { env: { ...process.env, JAVA_HOME: javaHome } });
+  return stdout;
+};
+
+const execAsync = promisify(exec);

package/src/dependencies/download.ts

@@ -0,0 +1,11 @@
+import axios from "axios";
+import fs from "fs";
+import stream from "stream";
+import util from "util";
+
+const pipeline = util.promisify(stream.pipeline);
+
+export const downloadFile = async (url: string, targetFile: string): Promise<void> => {
+  const request = await axios.get(url, { responseType: "stream" });
+  await pipeline(request.data, fs.createWriteStream(targetFile));
+};

package/src/dependencies/graalVm.ts

@@ -0,0 +1,74 @@
+import { existsSync } from "fs";
+import fs from "fs/promises";
+import decompress from "decompress";
+
+import { downloadFile } from "./download";
+import { logger } from "../log";
+import { osType, osArch } from "./os";
+import { versions } from "./versions";
+
+export const installGraalVm = async (gatlingHomeDir: string, downloadDir: string): Promise<string> => {
+  const { os, arch, extension, homePath, binPath } = graalVmPlatformParams();
+  const graalvmRootPath = `${gatlingHomeDir}/graalvm/${versions.graalvm.jdk}`;
+  const graalvmHomePath = `${graalvmRootPath}${homePath}`;
+  const graalvmJavaPath = `${graalvmHomePath}${binPath}`;
+
+  if (!existsSync(graalvmJavaPath)) {
+    const url = `https://github.com/graalvm/graalvm-ce-builds/releases/download/jdk-${versions.graalvm.jdk}/graalvm-community-jdk-${versions.graalvm.jdk}_${os}-${arch}_bin.${extension}`;
+    const downloadPath = `${downloadDir}/graalvm.${extension}`;
+
+    if (existsSync(graalvmRootPath)) {
+      await fs.rm(graalvmRootPath, { recursive: true });
+    }
+    if (existsSync(downloadPath)) {
+      await fs.rm(downloadPath);
+    }
+    await fs.mkdir(graalvmRootPath, { recursive: true });
+
+    logger.info(`Downloading GraalVM Community Edition ${versions.graalvm.jdk} to ${downloadPath}`);
+    await downloadFile(url, downloadPath);
+
+    logger.info(`Unpacking GraalVM to ${graalvmRootPath}`);
+    await decompress(downloadPath, graalvmRootPath, {
+      map: (file) => {
+        // Remove first level of file name, because it already contains a root directory
+        file.path = file.path.split("/").slice(1).join("/");
+        return file;
+      }
+    });
+
+    await fs.rm(downloadPath);
+  } else {
+    logger.info(`GraalVM Community Edition ${versions.graalvm.jdk} already installed at ${graalvmRootPath}`);
+  }
+
+  return graalvmHomePath;
+};
+
+const graalVmPlatformParams = () => {
+  if (osType === "Linux") {
+    const os = "linux";
+    const extension = "tar.gz";
+    const homePath = "";
+    const binPath = "/bin/java";
+    if (osArch === "x64") {
+      return { os, arch: "x64", extension, homePath, binPath };
+    } else if (osArch === "arm64") {
+      return { os, arch: "aarch64", extension, homePath, binPath };
+    }
+  } else if (osType === "Darwin") {
+    const os = "macos";
+    const extension = "tar.gz";
+    const homePath = "/Contents/Home";
+    const binPath = "/bin/java";
+    if (osArch === "x64") {
+      return { os, arch: "x64", extension, homePath, binPath };
+    } else if (osArch === "arm64") {
+      return { os, arch: "aarch64", extension, homePath, binPath };
+    }
+  } else if (osType === "Windows_NT" && osArch === "x64") {
+    return { os: "windows", arch: "x64", extension: "zip", homePath: "", binPath: "/bin/java.exe" };
+  }
+
+  throw Error(`Operating system type '${osType}' with architecture '${osArch}' is not currently supported.`);
+};

package/src/dependencies/index.ts

@@ -0,0 +1,44 @@
+import fs from "fs/promises";
+
+import { installCoursier, resolveGatlingJsDependencies, resolveRecorderDependencies } from "./coursier";
+import { installGraalVm } from "./graalVm";
+
+export { versions } from "./versions";
+
+export interface DependenciesOptions {
+  gatlingHome: string;
+}
+
+export interface ResolvedDependencies {
+  graalvmHome: string;
+  coursierBinary: string;
+  jvmClasspath: string;
+}
+
+export const installGatlingJs = async (options: DependenciesOptions): Promise<ResolvedDependencies> => {
+  const downloadDir = `${options.gatlingHome}/tmp/download`;
+  await fs.mkdir(downloadDir, { recursive: true });
+
+  const graalvmHomePath = await installGraalVm(options.gatlingHome, downloadDir);
+  const coursierPath = await installCoursier(options.gatlingHome, downloadDir);
+  const classpath = await resolveGatlingJsDependencies(coursierPath, graalvmHomePath);
+  return {
+    graalvmHome: graalvmHomePath,
+    coursierBinary: coursierPath,
+    jvmClasspath: classpath.trim()
+  };
+};
+
+export const installRecorder = async (options: DependenciesOptions): Promise<ResolvedDependencies> => {
+  const downloadDir = `${options.gatlingHome}/tmp/download`;
+  await fs.mkdir(downloadDir, { recursive: true });
+
+  const graalvmHomePath = await installGraalVm(options.gatlingHome, downloadDir);
+  const coursierPath = await installCoursier(options.gatlingHome, downloadDir);
+  const classpath = await resolveRecorderDependencies(coursierPath, graalvmHomePath);
+  return {
+    graalvmHome: graalvmHomePath,
+    coursierBinary: coursierPath,
+    jvmClasspath: classpath.trim()
+  };
+};

package/src/dependencies/os.ts

@@ -0,0 +1,24 @@
+import os from "os";
+
+const resolveOsType = () => {
+  const t = os.type();
+  if (t !== "Darwin" && t !== "Linux" && t !== "Windows_NT") {
+    throw Error(`Gatling JS does not support the Operating System '${t}'`);
+  }
+  return t;
+};
+export const osType: "Darwin" | "Linux" | "Windows_NT" = resolveOsType();
+
+const resolveOsArch = () => {
+  const a = os.arch();
+  if (a !== "x64" && a !== "arm64") {
+    throw Error(`Gatling JS does not support the architecture '${a}'`);
+  }
+  if (osType === "Windows_NT" && a === "arm64") {
+    // GraalVM distribution not available for Windows on ARM
+    // TODO see if we can recommend a solution
+    throw Error(`Gatling JS does not support Windows on the ARM architecture`);
+  }
+  return a;
+};
+export const osArch: "x64" | "arm64" = resolveOsArch();

package/src/dependencies/versions.ts

@@ -0,0 +1,12 @@
+export const versions = {
+  graalvm: {
+    jdk: "22.0.2",
+    js: "24.0.2"
+  },
+  coursier: "2.1.10",
+  gatling: {
+    core: "3.12.0",
+    enterprisePluginCommons: "1.9.6",
+    jsAdapter: "3.12.0"
+  }
+};

package/src/enterprise.ts

@@ -0,0 +1,225 @@
+import archiver from "archiver";
+import fs from "fs";
+import { pipeline } from "stream/promises";
+import { constants as zConstants } from "zlib";
+
+import { versions } from "./dependencies";
+import { RunJavaProcessOptions, runJavaProcess } from "./java";
+import { logger } from "./log";
+import { SimulationFile } from "./simulations";
+
+export interface EnterprisePackageOptions {
+  bundleFile: string;
+  resourcesFolder: string;
+  packageFile: string;
+  simulations: SimulationFile[];
+}
+
+export const enterprisePackage = async (options: EnterprisePackageOptions): Promise<void> => {
+  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.createWriteStream(options.packageFile);
+
+  const archive = archiver("zip", {
+    zlib: { level: zConstants.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 pipeline(archive, output);
+
+  logger.info(`Package for Gatling Enterprise created at ${options.packageFile}`);
+};
+
+const generateManifest = (simulationNames: string[]) => {
+  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.gatling.core}`,
+    "Gatling-Packager: js-cli",
+    `Gatling-Packager-Version: ${versions.gatling.jsAdapter}`,
+    `Gatling-Simulations: ${simulationNames.join(",")}`,
+    `Java-Version: ${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: Uint8Array[] = [];
+  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 = (): { name: string; version?: string } => {
+  // 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.existsSync("package.json")) {
+      throw Error("package.json not found");
+    }
+    const pkg = JSON.parse(fs.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 as string, version: version };
+};
+
+export interface EnterprisePluginOptions extends RunJavaProcessOptions {
+  bundleFile: string;
+  resourcesFolder: string;
+  resultsFolder: string;
+  // Base
+  url: string;
+  apiToken?: string;
+  // Plugin configuration
+  controlPlaneUrl?: string;
+  nonInteractive: boolean;
+}
+
+const javaArgsFromPluginOptions = (options: EnterprisePluginOptions) => {
+  const javaArgs: string[] = [];
+
+  // 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.gatling.jsAdapter}`);
+
+  if (options.nonInteractive) {
+    javaArgs.push(`-Dgatling.enterprise.batchMode=true`);
+  }
+
+  return javaArgs;
+};
+
+export interface EnterpriseDeployOptions extends EnterprisePluginOptions {
+  // Descriptor file
+  packageDescriptorFilename: string;
+  // Deployment info
+  packageFile: string;
+}
+
+const javaArgsFromDeployOptions = (options: EnterpriseDeployOptions) => {
+  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;
+};
+
+export const enterpriseDeploy = async (options: EnterpriseDeployOptions): Promise<void> => {
+  const additionalClasspathElements = [options.resourcesFolder];
+  const javaArgs = javaArgsFromDeployOptions(options);
+
+  if (process.env["DEBUG"] === "true") {
+    logger.debug("Java arguments:");
+    for (let i = 0; i < javaArgs.length; i++) {
+      logger.debug("  " + javaArgs[i]);
+    }
+  }
+
+  return runJavaProcess(options, "io.gatling.plugin.cli.EnterpriseDeploy", additionalClasspathElements, javaArgs, []);
+};
+
+export interface EnterpriseStartOptions extends EnterpriseDeployOptions {
+  enterpriseSimulation?: string;
+  runTitle?: string;
+  runDescription?: string;
+  waitForRunEnd?: boolean;
+}
+
+export const enterpriseStart = async (options: EnterpriseStartOptions): Promise<void> => {
+  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") {
+    logger.debug("Java arguments:");
+    for (let i = 0; i < javaArgs.length; i++) {
+      logger.debug("  " + javaArgs[i]);
+    }
+  }
+
+  return runJavaProcess(options, "io.gatling.plugin.cli.EnterpriseStart", additionalClasspathElements, javaArgs, []);
+};

package/src/index.ts

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+
+import { program } from "./commands";
+
+program.parse(process.argv);