@mu1147-legend/cf-speed-test 1.0.2

package/README.md

@@ -0,0 +1,137 @@
+# 🚀 cf-speed-test
+
+A fast, lightweight CLI tool to test your internet speed directly from the terminal.
+
+Includes:
+
+* ⚡ Download speed
+* ⬆ Upload speed
+* 📡 Latency (Ping)
+* 📊 Jitter
+* 🔁 Multiple test rounds
+* 🎯 Parallel connections
+
+---
+
+## 📦 Installation
+
+### Run instantly (no install)
+
+```bash
+npx cf-speed-test
+```
+
+---
+
+### Install globally
+
+```bash
+npm install -g cf-speed-test
+```
+
+Then run:
+
+```bash
+netspeed
+```
+
+---
+
+## ⚙️ Usage
+
+```bash
+netspeed
+```
+
+---
+
+## 🛠️ Options
+
+You can customize the test using CLI flags:
+
+```bash
+netspeed --connections=4 --download=50 --upload=20 --rounds=2
+```
+
+### Available Options
+
+| Flag            | Description                       | Default |
+| --------------- | --------------------------------- | ------- |
+| `--connections` | Number of parallel connections    | `4`     |
+| `--download`    | Download size per connection (MB) | `50`    |
+| `--upload`      | Upload size per connection (MB)   | `20`    |
+| `--rounds`      | Number of test rounds             | `2`     |
+| `--json`        | Output result as JSON             | `false` |
+
+---
+
+## 📊 Example Output
+
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+🚀 Legendary Speed Test
+
+Round 1
+
+⬇ Testing download...
+[████████████████████] 100%  240 Mbps
+✔ Download: 238 Mbps
+
+⬆ Testing upload...
+[████████████████████] 100%  230 Mbps
+✔ Upload: 225 Mbps
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+Connections: 4
+Latency: 22 ms
+Jitter: 3 ms
+
+⬇ Download: 235 Mbps
+⬆ Upload:   220 Mbps
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+```
+
+---
+
+## 🌍 How it works
+
+* Uses parallel HTTP requests to measure bandwidth
+* Streams data in chunks for real-time speed calculation
+* Measures latency using lightweight HEAD requests
+* Calculates jitter based on multiple ping attempts
+
+---
+
+## ⚠️ Notes
+
+* Results may vary depending on your ISP and routing
+* CDN-based testing (Cloudflare) may show higher peak speeds
+* For best results:
+
+  * Use stable connection
+  * Avoid background downloads
+  * Run multiple rounds
+
+---
+
+## 🧪 Advanced Usage
+
+### JSON Output (for scripting)
+
+```bash
+netspeed --json
+```
+
+---
+
+### High Accuracy Mode
+
+```bash
+netspeed --connections=6 --download=100 --rounds=3
+```
+
+---
+
+## 📄 License
+
+MIT License

package/index.js

@@ -0,0 +1,98 @@
+#!/usr/bin/env node
+
+import chalk from "chalk";
+import { downloadTest, measureLatency, uploadTest } from "./utils.js";
+
+const controller = new AbortController();
+
+process.on("SIGINT", () => {
+    console.log("\n⚠️ Test aborted");
+    controller.abort();
+    process.exit(1);
+});
+
+// args
+const args = process.argv.slice(2);
+
+const getArg = (name, def) => {
+    const found = args.find((a) => a.startsWith(name));
+    return found ? parseInt(found.split("=")[1]) : def;
+};
+
+const isJSON = args.includes("--json");
+
+const CONNECTIONS = getArg("--connections", 2);
+const DOWNLOAD_MB = getArg("--download", 20);
+const UPLOAD_MB = getArg("--upload", 20);
+const ROUNDS = getArg("--rounds", 2);
+
+const DOWNLOAD_URL = `https://speed.cloudflare.com/__down?bytes=${DOWNLOAD_MB * 1024 * 1024}`;
+const UPLOAD_URL = `https://speed.cloudflare.com/__up`;
+
+async function run() {
+    console.log(chalk.gray("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"));
+    console.log(chalk.green("🚀 Legendary Speed Test\n"));
+
+    // latency
+    const { latency, jitter } = await measureLatency(DOWNLOAD_URL);
+
+    let dlArr = [];
+    let ulArr = [];
+
+    for (let i = 0; i < ROUNDS; i++) {
+        console.log(chalk.gray(`\nRound ${i + 1}\n`));
+
+        // 🔥 download with glowing animation
+        const dl = await downloadTest(
+            DOWNLOAD_URL,
+            CONNECTIONS,
+            controller.signal,
+        );
+
+        console.log(chalk.blue(`✔ Download: ${dl.toFixed(2)} Mbps`));
+
+        // 🔥 upload with glowing animation
+        const ul = await uploadTest(
+            UPLOAD_URL,
+            UPLOAD_MB,
+            CONNECTIONS,
+            controller.signal,
+        );
+
+        console.log(chalk.magenta(`✔ Upload:   ${ul.toFixed(2)} Mbps`));
+
+        dlArr.push(dl);
+        ulArr.push(ul);
+    }
+
+    const avg = (arr) => arr.reduce((a, b) => a + b, 0) / arr.length;
+
+    const result = {
+        download: avg(dlArr),
+        upload: avg(ulArr),
+        latency,
+        jitter,
+        connections: CONNECTIONS,
+    };
+
+    if (isJSON) {
+        console.log(JSON.stringify(result, null, 2));
+        return;
+    }
+
+    // final output
+    console.log(chalk.gray("\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"));
+    console.log(chalk.cyan(`Connections: ${CONNECTIONS}`));
+    console.log(chalk.yellow(`Latency: ${latency.toFixed(2)} ms`));
+    console.log(chalk.yellow(`Jitter:  ${jitter.toFixed(2)} ms\n`));
+
+    console.log(
+        chalk.blueBright(`⬇ Download: ${result.download.toFixed(2)} Mbps`),
+    );
+    console.log(
+        chalk.magentaBright(`⬆ Upload:   ${result.upload.toFixed(2)} Mbps`),
+    );
+    console.log(chalk.gray("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n"));
+}
+
+run();

package/package.json

@@ -0,0 +1,27 @@
+{
+    "name": "@mu1147-legend/cf-speed-test",
+    "author": "Muhammad Ullah",
+    "license": "MIT",
+    "version": "1.0.2",
+    "description": "CLI Speed Test Tool (Download, Upload, Ping, Jitter)",
+    "keywords": [
+        "speedtest",
+        "cli",
+        "internet",
+        "network",
+        "download",
+        "upload",
+        "ping",
+        "jitter",
+        "netspeed"
+    ],
+    "type": "module",
+    "bin": {
+        "netspeed": "index.js"
+    },
+    "dependencies": {
+        "chalk": "^5.3.0",
+        "gradient-string": "^3.0.0",
+        "ora": "^7.0.1"
+    }
+}

package/utils.js

@@ -0,0 +1,287 @@
+import gradient from "gradient-string";
+import { performance } from "node:perf_hooks";
+
+// ---------------- SAFE FETCH ----------------
+async function safeFetch(url, options = {}, timeout = 8000, retries = 2) {
+    for (let attempt = 0; attempt <= retries; attempt++) {
+        const controller = new AbortController();
+        const id = setTimeout(() => controller.abort(), timeout);
+
+        try {
+            const res = await fetch(url, {
+                ...options,
+                signal: controller.signal,
+            });
+
+            clearTimeout(id);
+            return res;
+        } catch (err) {
+            clearTimeout(id);
+
+            if (attempt === retries) {
+                throw err;
+            }
+
+            // small delay before retry
+            await new Promise((r) => setTimeout(r, 800));
+        }
+    }
+}
+
+// Simplified fetch for POST (no retry to avoid stream reuse issues)
+async function postFetch(url, options = {}) {
+    return fetch(url, options);
+}
+
+// ---------------- LATENCY ----------------
+export async function measureLatency(url, attempts = 5) {
+    const times = [];
+
+    for (let i = 0; i < attempts; i++) {
+        const start = performance.now();
+        await safeFetch(url, { method: "HEAD", cache: "no-store" });
+        const end = performance.now();
+
+        times.push(end - start);
+    }
+
+    const avg = times.reduce((a, b) => a + b, 0) / times.length;
+
+    const jitter =
+        times.reduce((a, b) => a + Math.abs(b - avg), 0) / times.length;
+
+    return { latency: avg, jitter };
+}
+
+// ---------------- PROGRESS ----------------
+function renderProgress(percent, speed) {
+    const width = 20;
+    const safePercent = Math.max(0, Math.min(100, percent));
+
+    const filled = Math.round((safePercent / 100) * width);
+    const bar = "█".repeat(filled) + "░".repeat(width - filled);
+
+    process.stdout.write(
+        `\r[${bar}] ${safePercent.toFixed(0)}%  ${speed.toFixed(2)} Mbps`,
+    );
+}
+
+// ---------------- DOWNLOAD (FIXED) ----------------
+export async function downloadTest(url, connections, signal) {
+    const sizeMatch = url.match(/bytes=(\d+)/);
+    const fileSize = sizeMatch ? parseInt(sizeMatch[1]) : 0;
+
+    const totalBytes = fileSize * connections;
+
+    const progressArr = new Array(connections).fill(0);
+    let frameCount = 0;
+
+    const start = performance.now();
+
+    function renderDownloadProgress(percent, speed) {
+        const width = 20;
+        const safePercent = Math.max(0, Math.min(100, percent));
+        const filled = Math.round((safePercent / 100) * width);
+        const bar = "█".repeat(filled) + "░".repeat(width - filled);
+
+        // Stone gradient glowing animation - every frame
+        const clamp = (v) => Math.max(0, Math.min(1, v));
+        const shift = (frameCount % 20) / 20;
+
+        const animatedText = gradient([
+            { color: "#555555", pos: 0 },
+            { color: "#aaaaaa", pos: clamp(shift) },
+            { color: "#ffffff", pos: clamp(shift + 0.1) },
+            { color: "#aaaaaa", pos: clamp(shift + 0.2) },
+            { color: "#555555", pos: 1 },
+        ])(`⬇ Testing download...`);
+
+        process.stdout.write(
+            `\r${animatedText} [${bar}] ${speed.toFixed(2)} Mbps`,
+        );
+
+        frameCount++;
+    }
+
+    const streams = await Promise.all(
+        Array.from({ length: connections }, async (_, i) => {
+            // 🔥 random delay per connection
+            const randomDelay = Math.random() * 2000;
+            await new Promise((r) => setTimeout(r, randomDelay));
+
+            const res = await safeFetch(url, {
+                method: "GET", // ✅ MUST
+                cache: "no-store",
+                signal,
+            });
+
+            if (!res.body) return null;
+
+            return { stream: res.body, index: i };
+        }),
+    );
+
+    await Promise.all(
+        streams.map(async (item) => {
+            if (!item) return;
+
+            const { stream, index } = item;
+
+            try {
+                for await (const chunk of stream) {
+                    if (signal?.aborted) return;
+
+                    progressArr[index] += chunk.length;
+
+                    const receivedBytes = progressArr.reduce(
+                        (a, b) => a + b,
+                        0,
+                    );
+
+                    const elapsed = (performance.now() - start) / 1000;
+                    if (elapsed <= 0) continue;
+
+                    const speed = (receivedBytes * 8) / (elapsed * 1024 * 1024);
+
+                    const percent = totalBytes
+                        ? (receivedBytes / totalBytes) * 100
+                        : 0;
+
+                    renderDownloadProgress(percent, speed);
+                }
+            } catch (err) {
+                if (err.name !== "AbortError") {
+                    console.error("\nDownload error:", err.message);
+                }
+            }
+        }),
+    );
+
+    process.stdout.write("\n");
+
+    const duration = (performance.now() - start) / 1000;
+    const finalBytes = progressArr.reduce((a, b) => a + b, 0);
+
+    if (duration <= 0) return 0;
+
+    return (finalBytes * 8) / (duration * 1024 * 1024);
+}
+
+// ---------------- UPLOAD ----------------
+export async function uploadTest(url, sizeMB, connections, signal) {
+    const totalBytes = sizeMB * 1024 * 1024 * connections;
+
+    let uploadedBytes = 0;
+    let frameCount = 0;
+
+    const start = performance.now();
+
+    function renderProgress(percent, speed) {
+        const width = 20;
+        const filled = Math.round((percent / 100) * width);
+        const bar = "█".repeat(filled) + "░".repeat(width - filled);
+
+        // Stone gradient glowing animation - every frame
+        const clamp = (v) => Math.max(0, Math.min(1, v));
+        const shift = (frameCount % 20) / 20;
+
+        const animatedText = gradient([
+            { color: "#555555", pos: 0 },
+            { color: "#aaaaaa", pos: clamp(shift) },
+            { color: "#ffffff", pos: clamp(shift + 0.1) },
+            { color: "#aaaaaa", pos: clamp(shift + 0.2) },
+            { color: "#555555", pos: 1 },
+        ])(`⬆ Testing upload...`);
+
+        process.stdout.write(
+            `\r${animatedText} [${bar}] ${speed.toFixed(2)} Mbps`,
+        );
+
+        frameCount++;
+    }
+
+    const uploadOne = async () => {
+        const chunkSize = 256 * 1024; // 256KB
+        const totalChunks = (sizeMB * 1024 * 1024) / chunkSize;
+
+        const stream = new ReadableStream({
+            async pull(controller) {
+                if (signal?.aborted) {
+                    controller.close();
+                    return;
+                }
+
+                if (uploadedBytes >= totalBytes) {
+                    controller.close();
+                    return;
+                }
+
+                const chunk = new Uint8Array(chunkSize);
+                controller.enqueue(chunk);
+
+                uploadedBytes += chunk.length;
+
+                const elapsed = (performance.now() - start) / 1000;
+                if (elapsed <= 0) return;
+
+                const speed = (uploadedBytes * 8) / (elapsed * 1024 * 1024);
+
+                const percent = (uploadedBytes / totalBytes) * 100;
+
+                renderProgress(percent, speed);
+            },
+        });
+
+        await postFetch(url, {
+            method: "POST",
+            body: stream,
+            duplex: "half",
+            signal,
+        });
+    };
+
+    // parallel uploads
+    await Promise.all(Array.from({ length: connections }, () => uploadOne()));
+
+    process.stdout.write("\n");
+
+    const duration = (performance.now() - start) / 1000;
+
+    if (duration <= 0) return 0;
+
+    return (uploadedBytes * 8) / (duration * 1024 * 1024);
+}
+
+// ---------------- ANIMATION ----------------
+export function animateLoop(text) {
+    let i = 0;
+    let running = true;
+
+    const clamp = (v) => Math.max(0, Math.min(1, v));
+
+    const loop = () => {
+        if (!running) return;
+
+        const shift = (i % 20) / 20;
+
+        const colored = gradient([
+            { color: "#555555", pos: 0 },
+            { color: "#aaaaaa", pos: clamp(shift) },
+            { color: "#ffffff", pos: clamp(shift + 0.1) },
+            { color: "#aaaaaa", pos: clamp(shift + 0.2) },
+            { color: "#555555", pos: 1 },
+        ])(text);
+
+        process.stdout.write("\r" + colored);
+
+        i++;
+        setTimeout(loop, 50);
+    };
+
+    loop();
+
+    return () => {
+        running = false;
+        process.stdout.write("\r");
+    };
+}