idlebench 1.0.0 → 1.0.2

package/dist/commands/run.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"run.d.ts","sourceRoot":"","sources":["../../src/commands/run.ts"],"names":[],"mappings":"AAmIA,wBAAsB,mBAAmB,kBAgNxC"}
+{"version":3,"file":"run.d.ts","sourceRoot":"","sources":["../../src/commands/run.ts"],"names":[],"mappings":"AA8IA,wBAAsB,mBAAmB,kBAgMxC"}

package/dist/commands/run.js

@@ -9,23 +9,25 @@ import { getNetworkInfo } from '../lib/network.js';
 import { runBenchmark } from '../lib/benchmark.js';
 import { calculateGpuScore, calculateRuntimeScore, calculateNetworkScore, calculateInferenceScore, calculateStabilityScore, calculateFinalScore, getGrade, } from '../lib/scoring.js';
 import { buildReport, saveReportLocally } from '../lib/report.js';
-const CLI_VERSION = '1.0.0';
-const DEFAULT_API_URL = 'https://idlebench.com';
+import { createRequire } from 'module';
+const require = createRequire(import.meta.url);
+const { version: CLI_VERSION } = require('../../package.json');
+const DEFAULT_API_URL = 'https://idlebench.vercel.app';
 function line() {
     console.log(chalk.dim(' ─────────────────────────────────────────'));
 }
 function header() {
     console.log();
-    console.log(chalk.bold.white(' IdleBench'));
+    console.log(chalk.bold.white(' IdleBench') + chalk.dim(` v${CLI_VERSION}`));
     console.log(chalk.dim(' The verification layer for idle compute.'));
     console.log();
-    console.log(chalk.bgYellow.black(' SECURITY NOTICE ') + chalk.yellow(' IdleBench never asks for private keys or seed phrases.'));
+    console.log(chalk.bgYellow.black(' SECURITY ') + chalk.yellow(' IdleBench never asks for private keys or seed phrases.'));
     console.log();
     line();
     console.log();
 }
 function checkRow(label, value, ok) {
-    const icon = ok === true ? chalk.green('✓') : ok === false ? chalk.red('✗') : chalk.yellow('—');
+    const icon = ok === true ? chalk.green('✓') : ok === false ? chalk.red('✗') : chalk.dim('—');
     console.log(` ${icon}  ${chalk.dim(label.padEnd(26))} ${chalk.white(value)}`);
 }
 function scoreBar(label, score, width = 20) {
@@ -34,6 +36,31 @@ function scoreBar(label, score, width = 20) {
     const color = score >= 85 ? chalk.green : score >= 70 ? chalk.yellow : chalk.red;
     console.log(`  ${chalk.dim(label.padEnd(28))} ${color(bar)} ${chalk.bold(score)}`);
 }
+async function safeJsonFetch(url, options) {
+    let rawText = '';
+    try {
+        const res = await fetch(url, options);
+        rawText = await res.text();
+        let json;
+        try {
+            json = JSON.parse(rawText);
+        }
+        catch {
+            throw new Error(`Server returned non-JSON (HTTP ${res.status}). ` +
+                (rawText.length > 0 ? rawText.slice(0, 120) : 'Empty response.'));
+        }
+        if (!res.ok) {
+            const msg = typeof json.error === 'string' ? json.error : `HTTP ${res.status}`;
+            throw new Error(msg);
+        }
+        return json;
+    }
+    catch (err) {
+        if (err instanceof Error)
+            throw err;
+        throw new Error(`Network error: ${String(err)}`);
+    }
+}
 async function promptSetup() {
     console.log(chalk.dim(' Answer a few questions to configure your benchmark.\n'));
     const answers = await inquirer.prompt([
@@ -42,11 +69,11 @@ async function promptSetup() {
             name: 'providerWallet',
             message: 'Solana wallet address (public key):',
             validate: (input) => {
-                if (!input.trim())
+                const t = input.trim();
+                if (!t)
                     return 'Wallet address is required';
-                if (input.trim().length < 32 || input.trim().length > 44) {
-                    return 'Wallet address must be 32-44 characters';
-                }
+                if (t.length < 32 || t.length > 44)
+                    return 'Solana wallet address must be 32–44 characters';
                 return true;
             },
         },
@@ -74,7 +101,7 @@ async function promptSetup() {
         {
             type: 'input',
             name: 'idleGatewayUrl',
-            message: 'IDLE gateway URL (optional, press Enter to skip):',
+            message: 'IDLE endpoint URL (from earnidle.com, optional — press Enter to skip):',
             default: '',
             validate: (input) => {
                 if (!input.trim())
@@ -84,22 +111,7 @@ async function promptSetup() {
                     return true;
                 }
                 catch {
-                    return 'Enter a valid URL or leave blank';
-                }
-            },
-        },
-        {
-            type: 'input',
-            name: 'apiUrl',
-            message: `IdleBench API URL:`,
-            default: DEFAULT_API_URL,
-            validate: (input) => {
-                try {
-                    new URL(input.trim());
-                    return true;
-                }
-                catch {
-                    return 'Enter a valid URL';
+                    return 'Enter a valid URL (e.g. https://gateway.earnidle.com/ep/...) or leave blank';
                 }
             },
         },
@@ -109,7 +121,7 @@ async function promptSetup() {
         resourceName: answers.resourceName.trim(),
         resourceType: answers.resourceType,
         idleGatewayUrl: answers.idleGatewayUrl.trim() || null,
-        apiUrl: answers.apiUrl.trim(),
+        apiUrl: process.env.IDLEBENCH_API_URL?.trim() ?? DEFAULT_API_URL,
     };
 }
 export async function runBenchmarkCommand() {
@@ -135,7 +147,7 @@ export async function runBenchmarkCommand() {
         }
         catch (err) {
             spinner.fail('Failed to read system info');
-            throw err;
+            throw new Error(`System check failed: ${err instanceof Error ? err.message : err}`);
         }
     }
     console.log();
@@ -143,19 +155,25 @@ export async function runBenchmarkCommand() {
     let gpu;
     {
         const spinner = ora({ text: 'Detecting GPU', color: 'green' }).start();
-        gpu = await getGpuInfo();
-        spinner.succeed(chalk.dim('GPU detection'));
-        if (gpu.name) {
-            checkRow('GPU Model', gpu.name, true);
-            if (gpu.vramGb)
-                checkRow('VRAM', `${gpu.vramGb} GB`);
-            checkRow('CUDA', gpu.cudaAvailable ? `${gpu.cudaVersion ?? 'Available'}` : 'Not available', gpu.cudaAvailable);
-            if (gpu.driverVersion)
-                checkRow('NVIDIA Driver', gpu.driverVersion, true);
+        try {
+            gpu = await getGpuInfo();
+            spinner.succeed(chalk.dim('GPU detection'));
+            if (gpu.name) {
+                checkRow('GPU Model', gpu.name, true);
+                if (gpu.vramGb)
+                    checkRow('VRAM', `${gpu.vramGb} GB`);
+                checkRow('CUDA', gpu.cudaAvailable ? `${gpu.cudaVersion ?? 'Available'}` : 'Not available', gpu.cudaAvailable);
+                if (gpu.driverVersion)
+                    checkRow('NVIDIA Driver', gpu.driverVersion, true);
+            }
+            else {
+                checkRow('GPU', 'Not detected', null);
+                console.log(chalk.dim('  → No GPU found. Running CPU-only checks.'));
+            }
         }
-        else {
-            checkRow('GPU', 'Not detected', null);
-            console.log(chalk.dim('  No GPU detected — running CPU-only checks'));
+        catch (err) {
+            spinner.warn('GPU detection failed — continuing');
+            gpu = { name: null, vendor: null, vramGb: null, cudaAvailable: false, cudaVersion: null, driverVersion: null, temperature: null, utilizationPercent: null, detectionMethod: 'failed' };
         }
     }
     console.log();
@@ -163,72 +181,62 @@ export async function runBenchmarkCommand() {
     let docker;
     {
         const spinner = ora({ text: 'Checking Docker', color: 'green' }).start();
-        docker = await getDockerInfo();
-        spinner.succeed(chalk.dim('Docker check'));
-        checkRow('Docker', docker.available ? `v${docker.version}` : 'Not installed', docker.available);
-        if (docker.available) {
-            if (docker.gpuRuntime) {
-                checkRow('Docker GPU Runtime', 'Available', true);
-            }
-            else {
-                checkRow('Docker GPU Runtime', docker.gpuRuntimeError ?? 'Not available', false);
+        try {
+            docker = await getDockerInfo();
+            spinner.succeed(chalk.dim('Docker check'));
+            checkRow('Docker', docker.available ? `v${docker.version}` : 'Not installed', docker.available);
+            if (docker.available) {
+                checkRow('Docker GPU Runtime', docker.gpuRuntime ? 'Available' : (docker.gpuRuntimeError ?? 'Not available'), docker.gpuRuntime);
             }
         }
+        catch (err) {
+            spinner.warn('Docker check failed — continuing');
+            docker = { available: false, version: null, gpuRuntime: false, gpuRuntimeError: 'Check failed' };
+        }
     }
     console.log();
     // Benchmark
     let benchmarkResult;
     {
         const spinner = ora({ text: 'Running benchmark', color: 'green' }).start();
-        benchmarkResult = await runBenchmark();
-        spinner.succeed(chalk.dim('Benchmark complete'));
-        checkRow('CPU hash workload', `${benchmarkResult.cpuHashMs}ms`);
-        checkRow('Matrix calculation', `${benchmarkResult.matrixMs}ms`);
+        try {
+            benchmarkResult = await runBenchmark();
+            spinner.succeed(chalk.dim('Benchmark complete'));
+            checkRow('CPU hash workload', `${benchmarkResult.cpuHashMs}ms`);
+            checkRow('Matrix calculation', `${benchmarkResult.matrixMs}ms`);
+        }
+        catch (err) {
+            spinner.warn('Benchmark failed — using defaults');
+            benchmarkResult = { cpuHashMs: 500, matrixMs: 500, totalMs: 1000 };
+        }
     }
     console.log();
     // Network
     let network;
     {
         const spinner = ora({ text: 'Testing network', color: 'green' }).start();
-        network = await getNetworkInfo(apiUrl);
-        spinner.succeed(chalk.dim('Network check'));
-        checkRow('Latency', network.latencyMs !== null ? `${network.latencyMs}ms` : 'Could not measure', network.latencyMs !== null);
-        if (network.downloadMbps !== null) {
-            checkRow('Download estimate', `${network.downloadMbps} Mbps`);
+        try {
+            network = await getNetworkInfo(apiUrl);
+            spinner.succeed(chalk.dim('Network check'));
+            checkRow('Latency', network.latencyMs !== null ? `${network.latencyMs}ms` : 'Could not measure', network.latencyMs !== null && network.latencyMs < 500);
+            if (network.downloadMbps !== null)
+                checkRow('Download estimate', `${network.downloadMbps} Mbps`);
+        }
+        catch (err) {
+            spinner.warn('Network check failed — continuing');
+            network = { latencyMs: null, downloadMbps: null, uploadMbps: null };
         }
     }
     console.log();
     line();
     console.log();
     // Calculate scores
-    const gpuScore = calculateGpuScore({
-        gpuName: gpu.name,
-        vramGb: gpu.vramGb,
-        cpuCores: system.cpuCores,
-        ramGb: system.ramGb,
-        cudaAvailable: gpu.cudaAvailable,
-        dockerAvailable: docker.available,
-        dockerGpuRuntime: docker.gpuRuntime,
-    });
-    const runtimeScore = calculateRuntimeScore({
-        gpuName: gpu.name,
-        vramGb: gpu.vramGb,
-        cpuCores: system.cpuCores,
-        ramGb: system.ramGb,
-        cudaAvailable: gpu.cudaAvailable,
-        dockerAvailable: docker.available,
-        dockerGpuRuntime: docker.gpuRuntime,
-    });
+    const gpuScore = calculateGpuScore({ gpuName: gpu.name, vramGb: gpu.vramGb, cpuCores: system.cpuCores, ramGb: system.ramGb, cudaAvailable: gpu.cudaAvailable, dockerAvailable: docker.available, dockerGpuRuntime: docker.gpuRuntime });
+    const runtimeScore = calculateRuntimeScore({ gpuName: gpu.name, vramGb: gpu.vramGb, cpuCores: system.cpuCores, ramGb: system.ramGb, cudaAvailable: gpu.cudaAvailable, dockerAvailable: docker.available, dockerGpuRuntime: docker.gpuRuntime });
     const networkScore = calculateNetworkScore(network.latencyMs);
     const inferenceScore = calculateInferenceScore(system.cpuCores, system.ramGb, benchmarkResult.totalMs, gpu.name);
     const stabilityScore = calculateStabilityScore(system.cpuCores, system.ramGb);
-    const finalScore = calculateFinalScore({
-        gpuScore,
-        runtimeScore,
-        networkScore,
-        inferenceScore,
-        stabilityScore,
-    });
+    const finalScore = calculateFinalScore({ gpuScore, runtimeScore, networkScore, inferenceScore, stabilityScore });
     const grade = getGrade(finalScore);
     console.log(chalk.bold(' Score breakdown'));
     console.log();
@@ -243,7 +251,7 @@ export async function runBenchmarkCommand() {
     console.log();
     line();
     console.log();
-    // Build report
+    // Build + save report
     const report = buildReport({
         reportVersion: '1.0.0',
         providerWallet,
@@ -258,27 +266,25 @@ export async function runBenchmarkCommand() {
         benchmarkMs: benchmarkResult.totalMs,
         cliVersion: CLI_VERSION,
     });
-    // Save locally
-    const localPath = saveReportLocally(report);
-    console.log(chalk.dim(` Report saved locally: ${localPath}`));
+    let localPath;
+    try {
+        localPath = saveReportLocally(report);
+        console.log(chalk.dim(` Report saved locally: ${localPath}`));
+    }
+    catch {
+        localPath = 'unknown';
+        console.log(chalk.dim(' Could not save report locally.'));
+    }
     console.log();
     // Upload
     const uploadSpinner = ora({ text: `Uploading to ${apiUrl}`, color: 'green' }).start();
     try {
-        const res = await fetch(`${apiUrl}/api/reports/upload`, {
+        const json = await safeJsonFetch(`${apiUrl}/api/reports/upload`, {
             method: 'POST',
             headers: { 'Content-Type': 'application/json' },
             body: JSON.stringify(report),
             signal: AbortSignal.timeout(30000),
         });
-        const json = await res.json();
-        if (!res.ok) {
-            uploadSpinner.fail('Upload failed');
-            console.error(chalk.red(` ✗ Server error: ${JSON.stringify(json)}`));
-            console.log(chalk.dim(` Your report was saved locally: ${localPath}`));
-            console.log(chalk.dim(` You can upload it later with: idlebench upload ${localPath}`));
-            return;
-        }
         uploadSpinner.succeed('Report uploaded');
         console.log();
         console.log(chalk.bold(' Benchmark complete.'));
@@ -288,15 +294,16 @@ export async function runBenchmarkCommand() {
         console.log(chalk.dim('  Public URL:      '), chalk.cyan(String(json.publicUrl)));
         console.log(chalk.dim('  Local report:    '), chalk.dim(localPath));
         console.log();
-        console.log(chalk.dim(' Attach the badge to your IDLE listing or GitHub README:'));
-        console.log(chalk.dim(` Badge URL: ${apiUrl}/api/badge/${json.resourceId}`));
+        console.log(chalk.dim(`  Badge: ${apiUrl}/api/badge/${json.resourceId}`));
         console.log();
     }
     catch (err) {
-        uploadSpinner.fail('Upload failed — network error');
+        uploadSpinner.fail('Upload failed');
+        console.error();
         console.error(chalk.red(` ✗ ${err instanceof Error ? err.message : err}`));
-        console.log();
+        console.error();
         console.log(chalk.dim(` Your report was saved locally: ${localPath}`));
         console.log(chalk.dim(` Upload later with: idlebench upload ${localPath}`));
+        console.log();
     }
 }

package/dist/commands/upload.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"upload.d.ts","sourceRoot":"","sources":["../../src/commands/upload.ts"],"names":[],"mappings":"AAqCA,wBAAsB,SAAS,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE;IAAE,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,iBA2D7E"}
+{"version":3,"file":"upload.d.ts","sourceRoot":"","sources":["../../src/commands/upload.ts"],"names":[],"mappings":"AAqCA,wBAAsB,SAAS,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE;IAAE,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,iBAoE7E"}

package/dist/commands/upload.js

@@ -65,10 +65,20 @@ export async function runUpload(filePath, options) {
             body: rawJson,
             signal: AbortSignal.timeout(30000),
         });
-        const json = await res.json();
+        const rawText = await res.text();
+        let json;
+        try {
+            json = JSON.parse(rawText);
+        }
+        catch {
+            spinner.fail('Upload failed');
+            console.error(chalk.red(` ✗ Server returned non-JSON (HTTP ${res.status}):`));
+            console.error(chalk.dim(`   ${rawText.slice(0, 200)}`));
+            process.exit(1);
+        }
         if (!res.ok) {
             spinner.fail('Upload failed');
-            console.error(chalk.red(` ✗ ${JSON.stringify(json)}`));
+            console.error(chalk.red(` ✗ ${typeof json.error === 'string' ? json.error : JSON.stringify(json)}`));
             process.exit(1);
         }
         spinner.succeed('Report uploaded');

package/dist/index.js

@@ -1,10 +1,12 @@
 #!/usr/bin/env node
 import { Command } from 'commander';
 import chalk from 'chalk';
+import { createRequire } from 'module';
 import { runBenchmarkCommand } from './commands/run.js';
 import { runDoctor } from './commands/doctor.js';
 import { runUpload } from './commands/upload.js';
-const VERSION = '1.0.0';
+const require = createRequire(import.meta.url);
+const { version: VERSION } = require('../package.json');
 const program = new Command();
 program
     .name('idlebench')

package/dist/lib/docker.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"docker.d.ts","sourceRoot":"","sources":["../../src/lib/docker.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,UAAU;IACzB,SAAS,EAAE,OAAO,CAAA;IAClB,OAAO,EAAE,MAAM,GAAG,IAAI,CAAA;IACtB,UAAU,EAAE,OAAO,CAAA;IACnB,eAAe,EAAE,MAAM,GAAG,IAAI,CAAA;CAC/B;AAED,wBAAsB,aAAa,IAAI,OAAO,CAAC,UAAU,CAAC,CAkDzD"}
+{"version":3,"file":"docker.d.ts","sourceRoot":"","sources":["../../src/lib/docker.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,UAAU;IACzB,SAAS,EAAE,OAAO,CAAA;IAClB,OAAO,EAAE,MAAM,GAAG,IAAI,CAAA;IACtB,UAAU,EAAE,OAAO,CAAA;IACnB,eAAe,EAAE,MAAM,GAAG,IAAI,CAAA;CAC/B;AAeD,wBAAsB,aAAa,IAAI,OAAO,CAAC,UAAU,CAAC,CAuCzD"}

package/dist/lib/docker.js

@@ -1,48 +1,48 @@
 import { execa } from 'execa';
-export async function getDockerInfo() {
-    // Check if docker is installed
-    let version = null;
+async function runCmd(cmd, args, timeoutMs = 8000) {
     try {
-        const { stdout } = await execa('docker', ['--version'], { timeout: 6000 });
-        const match = stdout.match(/Docker version ([\d.]+)/);
-        version = match ? match[1] : stdout.trim().split('\n')[0];
+        const { stdout } = await execa(cmd, args, {
+            timeout: timeoutMs,
+            shell: true, // use system shell — resolves PATH on Windows
+            reject: true,
+        });
+        return stdout.trim();
     }
     catch {
-        return { available: false, version: null, gpuRuntime: false, gpuRuntimeError: 'Docker not installed' };
+        return null;
     }
-    // Check docker daemon is running
-    try {
-        await execa('docker', ['info'], { timeout: 8000 });
+}
+export async function getDockerInfo() {
+    // Check version
+    const versionOut = await runCmd('docker', ['--version']);
+    if (!versionOut) {
+        return { available: false, version: null, gpuRuntime: false, gpuRuntimeError: 'Docker not found in PATH' };
     }
-    catch {
+    const match = versionOut.match(/Docker version ([\d.]+)/);
+    const version = match ? match[1] : versionOut.split('\n')[0];
+    // Check daemon is running
+    const infoOut = await runCmd('docker', ['info', '--format', '{{.ServerVersion}}'], 10000);
+    if (!infoOut) {
         return { available: false, version, gpuRuntime: false, gpuRuntimeError: 'Docker daemon not running' };
     }
-    // Try GPU runtime
+    // Test GPU passthrough
     let gpuRuntime = false;
     let gpuRuntimeError = null;
     try {
-        await execa('docker', [
-            'run', '--rm',
-            '--gpus', 'all',
-            'nvidia/cuda:12.3.0-base-ubuntu22.04',
-            'nvidia-smi', '-L',
-        ], { timeout: 60000 });
-        gpuRuntime = true;
+        const { stdout } = await execa('docker', ['run', '--rm', '--gpus', 'all', 'nvidia/cuda:12.3.0-base-ubuntu22.04', 'nvidia-smi', '-L'], { timeout: 60000, shell: true });
+        gpuRuntime = stdout.length > 0;
     }
     catch (err) {
-        gpuRuntimeError = err instanceof Error ? err.message : 'GPU runtime test failed';
-        // Check if it's a known non-GPU error vs docker error
-        if (gpuRuntimeError.includes('could not select device driver')) {
+        const msg = err instanceof Error ? err.message : String(err);
+        if (msg.includes('could not select device driver') || msg.includes('nvidia')) {
             gpuRuntimeError = 'NVIDIA container toolkit not installed';
         }
-        else if (gpuRuntimeError.includes('Unable to find image')) {
+        else if (msg.includes('Unable to find image')) {
             gpuRuntimeError = 'Could not pull test image';
         }
+        else {
+            gpuRuntimeError = 'GPU runtime not available';
+        }
     }
-    return {
-        available: true,
-        version,
-        gpuRuntime,
-        gpuRuntimeError,
-    };
+    return { available: true, version, gpuRuntime, gpuRuntimeError };
 }

package/dist/lib/gpu.js

@@ -5,7 +5,7 @@ async function tryNvidiaSmi() {
         const { stdout } = await execa('nvidia-smi', [
             '--query-gpu=name,memory.total,driver_version,utilization.gpu,temperature.gpu',
             '--format=csv,noheader,nounits',
-        ], { timeout: 8000 });
+        ], { timeout: 8000, shell: true });
         const lines = stdout.trim().split('\n');
         if (lines.length === 0)
             return null;
@@ -15,7 +15,7 @@ async function tryNvidiaSmi() {
         let cudaVersion = null;
         let cudaAvailable = false;
         try {
-            const { stdout: smiOut } = await execa('nvidia-smi', [], { timeout: 5000 });
+            const { stdout: smiOut } = await execa('nvidia-smi', [], { timeout: 5000, shell: true });
             const cudaMatch = smiOut.match(/CUDA Version:\s*([\d.]+)/);
             if (cudaMatch) {
                 cudaVersion = cudaMatch[1];

package/package.json

@@ -1,13 +1,10 @@
 {
   "name": "idlebench",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "Benchmark and verify idle compute before it earns. The CLI for IDLE compute providers.",
   "license": "MIT",
   "author": "IdleBench",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/idlebench/idlebench-cli"
-  },
+  "homepage": "https://idlebench.com",
   "keywords": [
     "benchmark",
     "gpu",
@@ -24,7 +21,8 @@
   "files": [
     "dist",
     "README.md",
-    "LICENSE"
+    "LICENSE",
+    "package.json"
   ],
   "scripts": {
     "build": "tsc",