@gatling.io/cli 3.11.7 → 3.13.1

package/src/dependencies/index.ts

@@ -0,0 +1,45 @@
+import fs from "fs/promises";
+
+import { installCoursier, resolveGatlingJsDependencies, resolveRecorderDependencies } from "./coursier";
+import { installGraalVm } from "./graalVm";
+
+export { versions } from "./versions";
+
+export interface DependenciesOptions {
+  gatlingHome: string;
+  postman?: 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, options.postman);
+  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,15 @@
+export const versions = {
+  graalvm: {
+    jdk: "23.0.0",
+    js: "24.1.1"
+  },
+  java: {
+    compilerRelease: "21"
+  },
+  coursier: "2.1.12",
+  gatling: {
+    core: "3.13.1",
+    enterprisePluginCommons: "1.9.8",
+    jsAdapter: "3.13.1"
+  }
+};

package/src/enterprise.ts

@@ -0,0 +1,227 @@
+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.java.compilerRelease}`
+  ];
+  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
+  apiUrl: string;
+  webAppUrl: string;
+  apiToken?: string;
+  // Plugin configuration
+  controlPlaneUrl?: string;
+  nonInteractive: boolean;
+}
+
+const javaArgsFromPluginOptions = (options: EnterprisePluginOptions) => {
+  const javaArgs: string[] = [];
+
+  // Base
+  javaArgs.push(`-Dgatling.enterprise.apiUrl=${options.apiUrl}`);
+  javaArgs.push(`-Dgatling.enterprise.webAppUrl=${options.webAppUrl}`);
+  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);

package/src/java.ts

@@ -0,0 +1,48 @@
+import { spawn } from "child_process";
+
+import { osType } from "./dependencies/os";
+import { logger } from "./log";
+
+export interface RunJavaProcessOptions {
+  graalvmHome: string;
+  jvmClasspath: string;
+}
+
+export const runJavaProcess = (
+  options: RunJavaProcessOptions,
+  mainClass: string,
+  additionalClasspathElements: string[],
+  javaArgs: string[],
+  mainClassArgs: string[]
+): Promise<void> => {
+  const command = `${options.graalvmHome}/bin/java`;
+  const classpathSeparator = 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 = spawn(command, allArgs, {
+    env: process.env,
+    stdio: [process.stdin, process.stdout, process.stderr]
+  });
+
+  return new Promise((resolve, reject) => {
+    spawned.on("error", (error) => 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));
+      }
+    });
+  });
+};

package/src/log.ts

@@ -0,0 +1,19 @@
+const debug: (message: string) => void =
+  // On Node.js, console.debug is just an alias to console.log, so we handle debug level ourselves
+  process.env["DEBUG"] === "true" ? console.debug : () => {};
+
+const info: (message: string) => void = console.info;
+
+const error: (message: string) => void = console.error;
+
+export interface Logger {
+  debug: (message: string) => void;
+  info: (message: string) => void;
+  error: (message: string) => void;
+}
+
+export const logger: Logger = {
+  debug,
+  info,
+  error
+};

package/src/readline.ts

@@ -0,0 +1,39 @@
+import { keyInSelect, BasicOptions } from "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
+export const keyInSelectPaginated = (items: string[], query?: any, options?: BasicOptions | undefined): number => {
+  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 = 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);
+    }
+  }
+};

package/src/run.ts

@@ -0,0 +1,67 @@
+import { logger } from "./log";
+import { versions } from "./dependencies";
+import { RunJavaProcessOptions, runJavaProcess } from "./java";
+
+export interface RunSimulationOptions extends RunJavaProcessOptions {
+  simulation: string;
+  bundleFile: string;
+  resourcesFolder: string;
+  resultsFolder: string;
+  memory?: number;
+  runParameters: Record<string, string>;
+}
+
+export interface RunRecorderOptions extends RunJavaProcessOptions {
+  sourcesFolder: string;
+  typescript: boolean;
+  resourcesFolder: string;
+}
+
+export const runSimulation = async (options: RunSimulationOptions): Promise<void> => {
+  logger.info(`Running a Gatling simulation with options:
+ - simulation: ${options.simulation}
+ - bundleFile: ${options.bundleFile}
+ - resourcesFolder: ${options.resourcesFolder}
+ - resultsFolder: ${options.resultsFolder}`);
+
+  const additionalClasspathElements = [options.resourcesFolder];
+  const jitTuningArgs = ["-XX:JVMCINativeLibraryThreadFraction=0.8", "-Dgraal.MethodInlineBailoutLimit=500"];
+  const memoryArgs = options.memory !== undefined ? [`-Xms${options.memory}M`, `-Xmx${options.memory}M`] : [];
+  const javaArgs = [
+    ...Object.entries(options.runParameters).map(([key, value]) => `-D${key}=${value}`),
+    `-Dgatling.js.bundle.filePath=${options.bundleFile}`,
+    `-Dgatling.js.simulation=${options.simulation}`,
+    ...jitTuningArgs,
+    ...memoryArgs
+  ];
+  const simulationArgs = [
+    "--results-folder",
+    options.resultsFolder,
+    "--simulation",
+    "io.gatling.js.JsSimulation",
+    "--launcher",
+    "gatling-js-cli",
+    "--build-tool-version",
+    versions.gatling.jsAdapter
+  ];
+
+  return runJavaProcess(options, "io.gatling.app.Gatling", additionalClasspathElements, javaArgs, simulationArgs);
+};
+
+export const runRecorder = async (options: RunRecorderOptions): Promise<void> => {
+  logger.info(`Running the Gatling Recorder with options:
+ - sourcesFolder: ${options.sourcesFolder}
+ - resourcesFolder: ${options.resourcesFolder}
+ - typescript: ${options.typescript}`);
+
+  const recorderArgs = [
+    "--simulations-folder",
+    options.sourcesFolder,
+    "--resources-folder",
+    options.resourcesFolder,
+    "--format",
+    options.typescript ? "typescript" : "javascript"
+  ];
+
+  return runJavaProcess(options, "io.gatling.recorder.GatlingRecorder", [], [], recorderArgs);
+};

package/src/simulations.ts

@@ -0,0 +1,29 @@
+import fs from "fs/promises";
+
+export interface SimulationFile {
+  path: string;
+  name: string;
+  type: "javascript" | "typescript";
+}
+
+export const findSimulations = async (sourcesFolder: string): Promise<Array<SimulationFile>> => {
+  const children = await fs.readdir(sourcesFolder, { recursive: false });
+  const simulations = children
+    .filter((path) => path.endsWith(".gatling.js") || path.endsWith(".gatling.ts"))
+    .map(
+      (path): SimulationFile => ({
+        path,
+        name: path.slice(0, -11),
+        type: path.endsWith(".ts") ? "typescript" : "javascript"
+      })
+    );
+  const duplicates = simulations.filter(
+    (value, index) => simulations.findIndex((other) => other.name === value.name) !== index
+  );
+  if (duplicates.length > 0) {
+    throw Error(
+      `Found ambiguous simulation name(s) ${duplicates.map((s) => s.name)}: found as both *.gatling.js and *.gatling.ts file(s)`
+    );
+  }
+  return simulations;
+};

package/target/{bundle.d.ts → bundle/index.d.ts}

@@ -1,7 +1,8 @@
-import { SimulationFile } from "./simulations";
+import { SimulationFile } from "../simulations";
 export interface BundleOptions {
     sourcesFolder: string;
     bundleFile: string;
+    postman?: string;
     typescript: boolean;
     simulations: SimulationFile[];
 }

package/target/{bundle.js → bundle/index.js}

@@ -29,7 +29,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.bundle = void 0;
 const esbuild = __importStar(require("esbuild"));
 const esbuild_plugin_tsc_1 = __importDefault(require("esbuild-plugin-tsc"));
-const log_1 = require("./log");
+const polyfill_1 = require("./polyfill");
+const log_1 = require("../log");
 const bundle = async (options) => {
     log_1.logger.info(`Bundling a Gatling simulation with options:
  - sourcesFolder: ${options.sourcesFolder}
@@ -37,12 +38,17 @@ const bundle = async (options) => {
  - typescript: ${options.typescript}`);
     const contents = options.simulations.map((s) => `export { default as "${s.name}" } from "./${s.path}";`).join("\n");
     const plugins = options.typescript ? [(0, esbuild_plugin_tsc_1.default)({ force: true })] : [];
+    if (options.postman !== undefined) {
+        plugins.push((0, polyfill_1.polyfill)());
+    }
     await esbuild.build({
         stdin: {
             contents,
             resolveDir: options.sourcesFolder
         },
         outfile: options.bundleFile,
+        platform: "neutral",
+        mainFields: ["main", "module"],
         bundle: true,
         minify: false,
         sourcemap: true,

package/target/bundle/polyfill.d.ts

@@ -0,0 +1,2 @@
+import type { Plugin } from "esbuild";
+export declare const polyfill: () => Plugin;

package/target/bundle/polyfill.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.polyfill = void 0;
+const url_1 = require("url");
+const path_1 = require("path");
+// This is largely inspired by https://github.com/cyco130/esbuild-plugin-polyfill-node
+const polyfill = () => ({
+    name: "gatling-js-polyfill",
+    setup: async (build) => {
+        // modules
+        const jspmResolved = await resolveImport(`@jspm/core/nodelibs/fs`);
+        build.onResolve({ filter: polyfillsFilter }, async ({ path }) => {
+            const [, , moduleName] = path.match(polyfillsFilter);
+            const resolved = customPolyfills.find((name) => name === moduleName)
+                ? (0, path_1.resolve)((0, path_1.dirname)(__filename), `../../polyfills/${moduleName}.js`)
+                : (0, path_1.resolve)(jspmResolved, `../../browser/${moduleName}.js`);
+            return { path: resolved };
+        });
+        // Globals
+        build.initialOptions.inject = build.initialOptions.inject || [];
+        const injectGlobal = (name) => build.initialOptions.inject.push((0, path_1.resolve)((0, path_1.dirname)(__filename), `../../polyfills/${name}.js`));
+        injectGlobal("global");
+    }
+});
+exports.polyfill = polyfill;
+const customPolyfills = ["crypto"];
+const jspmPolyfills = ["buffer", "path", "string_decoder"];
+// Other available jspm-core modules:
+// "_stream_duplex"
+// "_stream_passthrough"
+// "_stream_readable"
+// "_stream_transform"
+// "_stream_writable"
+// "assert"
+// "assert/strict"
+// "async_hooks"
+// "child_process"
+// "cluster"
+// "console"
+// "constants"
+// "crypto"
+// "dgram"
+// "diagnostics_channel"
+// "dns"
+// "domain"
+// "events"
+// "fs"
+// "fs/promises"
+// "http"
+// "http2"
+// "https"
+// "module"
+// "net"
+// "os"
+// "perf_hooks"
+// "process"
+// "punycode"
+// "querystring"
+// "readline"
+// "repl"
+// "stream"
+// "sys"
+// "timers"
+// "timers/promises"
+// "tls"
+// "tty"
+// "url"
+// "util"
+// "v8"
+// "vm"
+// "wasi"
+// "worker_threads"
+// "zlib"
+const polyfillsFilter = new RegExp(`^(node:)?(${jspmPolyfills.concat(customPolyfills).join("|")})$`);
+let importMetaResolve;
+const importMetaUrl = (0, url_1.pathToFileURL)(__filename).href;
+const resolveImport = async (specifier) => {
+    if (!importMetaResolve) {
+        importMetaResolve = (await import("import-meta-resolve")).resolve;
+    }
+    const resolved = importMetaResolve(specifier, importMetaUrl);
+    return (0, url_1.fileURLToPath)(resolved);
+};

package/target/commands/build.d.ts

@@ -0,0 +1,3 @@
+import { Command } from "commander";
+declare const _default: (program: Command) => void;
+export default _default;

package/target/commands/build.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const options_1 = require("./options");
+const simulations_1 = require("../simulations");
+const bundle_1 = require("../bundle");
+exports.default = (program) => {
+    program
+        .command("build")
+        .description("Build Gatling simulations")
+        .addOption(options_1.sourcesFolderOption)
+        .addOption(options_1.bundleFileOption)
+        .addOption(options_1.postmanOption)
+        .addOption(options_1.typescriptOption)
+        .action(async (options) => {
+        const sourcesFolder = (0, options_1.sourcesFolderOptionValue)(options);
+        const bundleFile = (0, options_1.bundleFileOptionValue)(options);
+        const simulations = await (0, simulations_1.findSimulations)(sourcesFolder);
+        const postman = (0, options_1.postmanOptionValueWithDefaults)(options);
+        const typescript = (0, options_1.typescriptOptionValueWithDefaults)(options, simulations);
+        await (0, bundle_1.bundle)({ sourcesFolder, bundleFile, postman, typescript, simulations });
+    });
+};