blaze-performance-tester 1.0.7 → 1.0.9

package/dist/cli.js

@@ -1,74 +1,37 @@
 #!/usr/bin/env node
-
-// index.js
-import { createRequire } from "module";
-var require2 = createRequire(import.meta.url);
-var nativeBinding = require2("./blaze.win32-x64-msvc.node");
-var runBlazeCore = nativeBinding.runBlazeCore;
+#!/usr/bin/env node
 
 // cli.ts
-import * as esbuild from "esbuild";
-import * as path from "node:path";
-async function main() {
-  const args = process.argv.slice(2);
-  if (args.length < 3) {
-    console.log("\u274C Missing arguments! Usage: npx tsx cli.ts <script> <vus> <seconds>");
-    process.exit(1);
-  }
-  const targetScript = path.resolve(process.cwd(), args[0]);
-  const bundled = await esbuild.build({
-    entryPoints: [targetScript],
-    bundle: true,
-    format: "iife",
-    write: false,
-    target: "es2020"
-  });
-  console.log(`\u{1F525} [Blaze] Injecting load tests using Blaze metrics aggregation engine...`);
-  const metrics = runBlazeCore(
-    bundled.outputFiles[0].text,
-    parseInt(args[1], 10),
-    parseInt(args[2], 10)
-  );
-  const samples = metrics.allRequests;
-  const totalRequests = samples.length;
-  if (totalRequests === 0) {
-    console.log("\u26A0\uFE0F No requests were completed successfully.");
-    return;
-  }
-  const latencies = samples.map((s) => s.latencyMs).sort((a, b) => a - b);
-  const totalErrors = samples.filter((s) => !s.isSuccess).length;
-  const sum = latencies.reduce((acc, v) => acc + v, 0);
-  const avg = sum / totalRequests;
-  const min = latencies[0];
-  const max = latencies[latencies.length - 1];
-  const getPercentile = (p) => {
-    const index = Math.ceil(p / 100 * latencies.length) - 1;
-    return latencies[Math.max(0, index)];
-  };
-  const p50 = getPercentile(50);
-  const p90 = getPercentile(90);
-  const p95 = getPercentile(95);
-  const p99 = getPercentile(99);
-  const realSec = metrics.totalDurationMs / 1e3;
-  const throughput = totalRequests / realSec;
-  const errorRate = totalErrors / totalRequests * 100;
-  console.log("\n\u{1F4CA} ==================== Blaze Performance Report ====================");
-  console.log(`  Target Script:      ${args[0]}`);
-  console.log(`  Active VUs:         ${args[1]} parallel threads`);
-  console.log(`  Elapsed Time:       ${realSec.toFixed(2)} seconds`);
-  console.log("-----------------------------------------------------------------------------");
-  console.log(`  Samples (Requests): ${totalRequests}`);
-  console.log(`  Throughput Rate:    ${throughput.toFixed(2)} req/sec`);
-  console.log(`  Error Rate:         ${errorRate.toFixed(2)}% (${totalErrors} failed)`);
-  console.log("-----------------------------------------------------------------------------");
-  console.log("\u{1F4C8} Latency Statistics (ms):");
-  console.log(`  \u2514\u2500\u2500 Minimum:        ${min.toFixed(2)} ms`);
-  console.log(`  \u2514\u2500\u2500 Average:        ${avg.toFixed(2)} ms`);
-  console.log(`  \u2514\u2500\u2500 Median (50%):   ${p50.toFixed(2)} ms`);
-  console.log(`  \u2514\u2500\u2500 90th %ile:      ${p90.toFixed(2)} ms`);
-  console.log(`  \u2514\u2500\u2500 95th %ile:      ${p95.toFixed(2)} ms`);
-  console.log(`  \u2514\u2500\u2500 99th %ile:      ${p99.toFixed(2)} ms`);
-  console.log(`  \u2514\u2500\u2500 Maximum:        ${max.toFixed(2)} ms`);
-  console.log("=============================================================================\n");
+import fs from "node:fs";
+import path from "node:path";
+import { createRequire } from "node:module";
+var require2 = createRequire(import.meta.url);
+var nativeBinding = require2("./index.js");
+var args = process.argv.slice(2);
+if (args.length < 3) {
+  console.error("\x1B[31m\u274C Missing arguments!\x1B[0m");
+  console.error("Usage: \x1B[36mnpx blaze-performance-tester <script-path> <vus> <duration-seconds>\x1B[0m");
+  process.exit(1);
+}
+var targetScript = args[0];
+var vusCount = parseInt(args[1], 10);
+var durationSeconds = parseInt(args[2], 10);
+var targetScriptPath = path.resolve(process.cwd(), targetScript);
+if (!fs.existsSync(targetScriptPath)) {
+  console.error(`\x1B[31m\u274C Target workload script not found at:\x1B[0m ${targetScriptPath}`);
+  process.exit(1);
+}
+var currentWorkingDirectory = process.cwd();
+var resultsFolder = path.join(currentWorkingDirectory, "results");
+if (!fs.existsSync(resultsFolder)) {
+  fs.mkdirSync(resultsFolder, { recursive: true });
+}
+var csvOutputPath = path.join(resultsFolder, "summary_report.csv");
+console.log(`\x1B[35m\u{1F525} Blaze Performance Tester Initialized... \x1B[0m`);
+console.log(`\u26A1 Spawning \x1B[32m${vusCount}\x1B[0m Virtual Users for \x1B[32m${durationSeconds}s\x1B[0m against scenario script.`);
+try {
+  nativeBinding.runBlazeCore(targetScriptPath, vusCount, durationSeconds, csvOutputPath);
+} catch (error) {
+  console.error("\x1B[31m\u{1F4A5} Critical Native Core Execution Error:\x1B[0m", error);
+  process.exit(1);
 }
-main().catch(console.error);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "blaze-performance-tester",
-  "version": "1.0.7",
+  "version": "1.0.9",
   "description": "A high-performance, multi-threaded load testing engine built with Rust and QuickJS.",
   "type": "module",
   "main": "dist/index.js",
@@ -18,7 +18,7 @@
 "scripts": {
     "prebuild": "node -e \"if (!fs.existsSync('dist')) fs.mkdirSync('dist')\"",
     "build:rust": "napi build --platform --release --js dist/index.js --dts dist/index.d.ts",
-    "build:cli": "esbuild cli.ts --bundle --platform=node --format=esm --packages=external --banner:js=\"#!/usr/bin/env node\" --outfile=dist/cli.js",
+    "build:cli": "esbuild cli.ts --bundle --platform=node --format=esm --packages=external --outfile=dist/cli.js",
     "postbuild": "node -e \"fs.copyFileSync('blaze.win32-x64-msvc.node', 'dist/blaze.win32-x64-msvc.node')\"",
     "build": "npm run build:rust && npm run build:cli && npm run postbuild"
   },

package/readme

@@ -1,3 +1,4 @@
+Markdown
 # 🔥 Blaze Performance Tester
 
 Blaze is an ultra-high-performance, multi-threaded load testing framework built with **Rust** and **QuickJS** (via `rquickjs`). It provides parallel virtual user execution by isolating JavaScript evaluation environments into dedicated native OS threads, delivering raw network speed and JMeter-style telemetry metrics with minimal footprint.
@@ -10,7 +11,7 @@ Blaze is an ultra-high-performance, multi-threaded load testing framework built
 * **Native HTTP Execution Sockets:** Exposes a global `http_get()` binding inside JavaScript that routes network calls directly through Rust's high-speed `reqwest` stack.
 * **JMeter-Style Telemetry Aggregation:** Computes live data snapshots including throughput rates, error tallies, and crucial latency percentiles ($p50$, $p90$, $p95$, $p99$).
 * **Real-Time Terminal Progress Updates:** Keeps you updated via a live terminal countdown ticker while heavy parallel workloads run.
-* **CSV Result Archiver:** Automatically records every workload run into structured `.csv` reports inside the `results/` folder for data charting.
+* **Zero-Configuration CSV Archiver:** Automatically records data into structured `.csv` reports inside a `results/` folder created dynamically wherever you invoke the command.
 
 ---
 
@@ -19,17 +20,17 @@ Blaze is an ultra-high-performance, multi-threaded load testing framework built
 ```text
 blaze-performance-tester/
 ├── dist/                  # Compiled Distribution Assets
-│   ├── cli.js             # Bundled CLI Wrapper Script
+│   ├── cli.js             # Bundled CLI Core
 │   ├── index.js           # Generated Native NAPI-RS Bridges
-│   └── index.d.ts         # TypeScript Type Structure Mappings
-├── results/               # Aggregated Report Output Artifacts
-│   └── summary_report.csv # JMeter-style CSV performance dump
+│   ├── index.d.ts         # TypeScript Type Structure Mappings
+│   └── blaze.*.node       # Compiled Native Rust Binary
 ├── src/
 │   └── lib.rs             # Multi-Threaded Rust Concurrency Core
 ├── tests/                 # Dedicated Folder for Performance Scripts
-│   └── demo-load-test.ts  # Scenario Workload Script
+│   └── test-script.ts     # Scenario Workload Script
+├── bin.js                 # Anti-Hijack Executable Gateway for Windows WSH
 ├── cli.ts                 # CLI Orchestration & Metrics Wrapper
-├── package.json           # Node Dependency Pipeline
+├── package.json           # Node Dependency & Build Script Pipeline
 └── Cargo.toml             # Rust Native Compilation Flags
 📦 Compilation & Installation
 Prerequisites
@@ -43,25 +44,27 @@ Setup & Build
 Clone the repository, download dependencies, and compile the native binary distribution bundle:
 
 Bash
-# Install node dependencies
+# Install package dependencies
 npm install
 
-# Compile the native Rust modules and bundle the TypeScript CLI wrapper
+# Compile the native Rust modules, copy binaries, and bundle the ESM CLI wrapper
 npm run build
 🏃 Run Performance Workloads
-To run a performance test script, call the core execution runner by passing your target test file, the number of parallel virtual users (VUs), and the test duration in seconds:
+Blaze can be executed globally from any terminal folder via npx without needing global system mutations.
 
-Bash
-# Usage: npx tsx cli.ts <script-path> <vus> <duration-seconds>
-npx tsx cli.ts tests/demo-load-test.ts 10 5
-Writing a Workload Script (tests/demo-load-test.ts)
-Your scripts have access to the injected, native http_get global socket binding:
+To run a test, navigate to your target project folder, create your script file, and call the runner passing the script path, the number of concurrent Virtual Users (VUs), and the test duration in seconds:
+
+DOS
+# Usage: npx blaze-performance-tester <script-path> <vus> <duration-seconds>
+npx blaze-performance-tester tests/test-script.ts 10 5
+Writing a Workload Script (tests/test-script.ts)
+Your script workloads have instant access to the injected high-speed global native socket binding:
 
 TypeScript
 // Call the high-speed native network layer directly
 const status = http_get("[https://jsonplaceholder.typicode.com/posts/1](https://jsonplaceholder.typicode.com/posts/1)");
 
-// The engine automatically registers response times and error states!
+// The native Rust engine automatically handles response times and error states!
 📊 Sample Performance Output Report
 When your test finishes running, Blaze renders a clean telemetry report right in your terminal and saves a copy to disk:
 
@@ -81,17 +84,12 @@ Plaintext
   └── Maximum:        12.40 ms
 =============================================================================
 💾 Aggregated metrics saved to: .\results\summary_report.csv
-🧙 Interactive Scaffolding Wizard (create-blaze-tester)
-We provide a companion initializer utility to quickly set up new projects with an organized workspace folder structure.
-
-To execute the setup wizard out of an empty workspace directory, run:
-
-Bash
-npm init blaze-tester
-This interactive prompt automatically:
-
-Provisions a dedicated tests/ directory.
+📂 Where are results stored?
+Blaze captures execution contexts using process.cwd(). The moment a test run completes successfully, a new directory is instantly written inside the user's active terminal directory:
 
-Injects an example boilerplate script file (demo-load-test.ts).
-
-Appends test runner shortcut hooks directly into your local package.json.
+Plaintext
+your-active-directory/
+├── tests/
+│   └── test-script.ts
+└── results/               <-- Generated Automatically
+    └── summary_report.csv <-- Contains Raw Timestamp, Latency, Status, and Success Flags