idlebench 1.0.0

package/dist/index.js

@@ -0,0 +1,78 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { runBenchmarkCommand } from './commands/run.js';
+import { runDoctor } from './commands/doctor.js';
+import { runUpload } from './commands/upload.js';
+const VERSION = '1.0.0';
+const program = new Command();
+program
+    .name('idlebench')
+    .description('Benchmark and verify idle compute before it earns.')
+    .version(VERSION, '-v, --version', 'Show CLI version');
+program
+    .command('run')
+    .description('Run a local benchmark and upload the report to IdleBench')
+    .option('--api-url <url>', 'IdleBench API URL (default: https://idlebench.com)')
+    .action(async (_options) => {
+    try {
+        await runBenchmarkCommand();
+    }
+    catch (err) {
+        console.error();
+        console.error(chalk.red(' ✗ Benchmark failed:'), err instanceof Error ? err.message : err);
+        console.error();
+        process.exit(1);
+    }
+});
+program
+    .command('doctor')
+    .description('Check local environment for benchmark readiness')
+    .option('--api-url <url>', 'IdleBench API URL to test connectivity')
+    .action(async (options) => {
+    try {
+        await runDoctor(options);
+    }
+    catch (err) {
+        console.error(chalk.red(' ✗ Doctor failed:'), err instanceof Error ? err.message : err);
+        process.exit(1);
+    }
+});
+program
+    .command('upload <path>')
+    .description('Upload an existing benchmark report JSON')
+    .option('--api-url <url>', 'IdleBench API URL (default: https://idlebench.com)')
+    .action(async (filePath, options) => {
+    try {
+        await runUpload(filePath, options);
+    }
+    catch (err) {
+        console.error(chalk.red(' ✗ Upload failed:'), err instanceof Error ? err.message : err);
+        process.exit(1);
+    }
+});
+program
+    .command('version')
+    .description('Show CLI version')
+    .action(() => {
+    console.log();
+    console.log(chalk.bold('idlebench'), chalk.dim(`v${VERSION}`));
+    console.log(chalk.dim('The verification layer for idle compute.'));
+    console.log();
+});
+// Default: show help if no args
+if (process.argv.length <= 2) {
+    console.log();
+    console.log(chalk.bold(' IdleBench') + chalk.dim(` v${VERSION}`));
+    console.log(chalk.dim(' The verification layer for idle compute.'));
+    console.log();
+    console.log(chalk.dim(' Usage:'));
+    console.log(`   ${chalk.white('npx idlebench run')}       ${chalk.dim('Run benchmark and publish score')}`);
+    console.log(`   ${chalk.white('npx idlebench doctor')}    ${chalk.dim('Check environment readiness')}`);
+    console.log(`   ${chalk.white('npx idlebench upload')}    ${chalk.dim('<path>  Upload saved report')}`);
+    console.log();
+    console.log(chalk.dim(' Run ') + chalk.white('idlebench --help') + chalk.dim(' for full options.'));
+    console.log();
+    process.exit(0);
+}
+program.parse(process.argv);

package/dist/lib/benchmark.d.ts

@@ -0,0 +1,7 @@
+export interface BenchmarkResult {
+    cpuHashMs: number;
+    matrixMs: number;
+    totalMs: number;
+}
+export declare function runBenchmark(): Promise<BenchmarkResult>;
+//# sourceMappingURL=benchmark.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"benchmark.d.ts","sourceRoot":"","sources":["../../src/lib/benchmark.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,eAAe;IAC9B,SAAS,EAAE,MAAM,CAAA;IACjB,QAAQ,EAAE,MAAM,CAAA;IAChB,OAAO,EAAE,MAAM,CAAA;CAChB;AAgCD,wBAAsB,YAAY,IAAI,OAAO,CAAC,eAAe,CAAC,CAY7D"}

package/dist/lib/benchmark.js

@@ -0,0 +1,34 @@
+import { createHash } from 'crypto';
+function hashWorkload(iterations) {
+    const start = Date.now();
+    let hash = '';
+    for (let i = 0; i < iterations; i++) {
+        hash = createHash('sha256').update(hash + i.toString()).digest('hex');
+    }
+    return Date.now() - start;
+}
+function matrixMultiply(size) {
+    const start = Date.now();
+    const a = Array.from({ length: size }, (_, i) => Array.from({ length: size }, (_, j) => i * size + j));
+    const b = Array.from({ length: size }, (_, i) => Array.from({ length: size }, (_, j) => j * size + i));
+    const c = Array.from({ length: size }, () => new Array(size).fill(0));
+    for (let i = 0; i < size; i++) {
+        for (let k = 0; k < size; k++) {
+            for (let j = 0; j < size; j++) {
+                c[i][j] += a[i][k] * b[k][j];
+            }
+        }
+    }
+    return Date.now() - start;
+}
+export async function runBenchmark() {
+    // CPU hash workload (2048 iterations of SHA-256)
+    const cpuHashMs = hashWorkload(2048);
+    // Matrix multiplication 128x128
+    const matrixMs = matrixMultiply(128);
+    return {
+        cpuHashMs,
+        matrixMs,
+        totalMs: cpuHashMs + matrixMs,
+    };
+}

package/dist/lib/docker.d.ts

@@ -0,0 +1,8 @@
+export interface DockerInfo {
+    available: boolean;
+    version: string | null;
+    gpuRuntime: boolean;
+    gpuRuntimeError: string | null;
+}
+export declare function getDockerInfo(): Promise<DockerInfo>;
+//# sourceMappingURL=docker.d.ts.map

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

@@ -0,0 +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"}

package/dist/lib/docker.js

@@ -0,0 +1,48 @@
+import { execa } from 'execa';
+export async function getDockerInfo() {
+    // Check if docker is installed
+    let version = null;
+    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];
+    }
+    catch {
+        return { available: false, version: null, gpuRuntime: false, gpuRuntimeError: 'Docker not installed' };
+    }
+    // Check docker daemon is running
+    try {
+        await execa('docker', ['info'], { timeout: 8000 });
+    }
+    catch {
+        return { available: false, version, gpuRuntime: false, gpuRuntimeError: 'Docker daemon not running' };
+    }
+    // Try GPU runtime
+    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;
+    }
+    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')) {
+            gpuRuntimeError = 'NVIDIA container toolkit not installed';
+        }
+        else if (gpuRuntimeError.includes('Unable to find image')) {
+            gpuRuntimeError = 'Could not pull test image';
+        }
+    }
+    return {
+        available: true,
+        version,
+        gpuRuntime,
+        gpuRuntimeError,
+    };
+}

package/dist/lib/gpu.d.ts

@@ -0,0 +1,13 @@
+export interface GpuInfo {
+    name: string | null;
+    vendor: string | null;
+    vramGb: number | null;
+    cudaAvailable: boolean;
+    cudaVersion: string | null;
+    driverVersion: string | null;
+    temperature: number | null;
+    utilizationPercent: number | null;
+    detectionMethod: string;
+}
+export declare function getGpuInfo(): Promise<GpuInfo>;
+//# sourceMappingURL=gpu.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"gpu.d.ts","sourceRoot":"","sources":["../../src/lib/gpu.ts"],"names":[],"mappings":"AAGA,MAAM,WAAW,OAAO;IACtB,IAAI,EAAE,MAAM,GAAG,IAAI,CAAA;IACnB,MAAM,EAAE,MAAM,GAAG,IAAI,CAAA;IACrB,MAAM,EAAE,MAAM,GAAG,IAAI,CAAA;IACrB,aAAa,EAAE,OAAO,CAAA;IACtB,WAAW,EAAE,MAAM,GAAG,IAAI,CAAA;IAC1B,aAAa,EAAE,MAAM,GAAG,IAAI,CAAA;IAC5B,WAAW,EAAE,MAAM,GAAG,IAAI,CAAA;IAC1B,kBAAkB,EAAE,MAAM,GAAG,IAAI,CAAA;IACjC,eAAe,EAAE,MAAM,CAAA;CACxB;AAiED,wBAAsB,UAAU,IAAI,OAAO,CAAC,OAAO,CAAC,CA0BnD"}

package/dist/lib/gpu.js

@@ -0,0 +1,86 @@
+import { execa } from 'execa';
+import si from 'systeminformation';
+async function tryNvidiaSmi() {
+    try {
+        const { stdout } = await execa('nvidia-smi', [
+            '--query-gpu=name,memory.total,driver_version,utilization.gpu,temperature.gpu',
+            '--format=csv,noheader,nounits',
+        ], { timeout: 8000 });
+        const lines = stdout.trim().split('\n');
+        if (lines.length === 0)
+            return null;
+        const parts = lines[0].split(',').map(s => s.trim());
+        const [name, vramMb, driver, utilization, temperature] = parts;
+        // Get CUDA version from nvcc or nvidia-smi
+        let cudaVersion = null;
+        let cudaAvailable = false;
+        try {
+            const { stdout: smiOut } = await execa('nvidia-smi', [], { timeout: 5000 });
+            const cudaMatch = smiOut.match(/CUDA Version:\s*([\d.]+)/);
+            if (cudaMatch) {
+                cudaVersion = cudaMatch[1];
+                cudaAvailable = true;
+            }
+        }
+        catch { }
+        return {
+            name: name || null,
+            vendor: 'NVIDIA',
+            vramGb: vramMb ? Math.round((parseFloat(vramMb) / 1024) * 10) / 10 : null,
+            driverVersion: driver || null,
+            cudaAvailable,
+            cudaVersion,
+            temperature: temperature ? parseFloat(temperature) : null,
+            utilizationPercent: utilization ? parseFloat(utilization) : null,
+            detectionMethod: 'nvidia-smi',
+        };
+    }
+    catch {
+        return null;
+    }
+}
+async function trySysinformation() {
+    try {
+        const graphics = await si.graphics();
+        if (!graphics.controllers || graphics.controllers.length === 0)
+            return null;
+        const gpu = graphics.controllers[0];
+        if (!gpu.model)
+            return null;
+        const isNvidia = gpu.vendor?.toLowerCase().includes('nvidia') || gpu.model?.toLowerCase().includes('nvidia');
+        return {
+            name: gpu.model,
+            vendor: gpu.vendor || (isNvidia ? 'NVIDIA' : null),
+            vramGb: gpu.vram ? Math.round((gpu.vram / 1024) * 10) / 10 : null,
+            cudaAvailable: isNvidia ? undefined : false,
+            detectionMethod: 'systeminformation',
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export async function getGpuInfo() {
+    const defaults = {
+        name: null,
+        vendor: null,
+        vramGb: null,
+        cudaAvailable: false,
+        cudaVersion: null,
+        driverVersion: null,
+        temperature: null,
+        utilizationPercent: null,
+        detectionMethod: 'none',
+    };
+    // Try nvidia-smi first (most accurate for NVIDIA)
+    const nvidiaSmi = await tryNvidiaSmi();
+    if (nvidiaSmi && nvidiaSmi.name) {
+        return { ...defaults, ...nvidiaSmi };
+    }
+    // Fallback to systeminformation
+    const siGpu = await trySysinformation();
+    if (siGpu && siGpu.name) {
+        return { ...defaults, ...siGpu };
+    }
+    return defaults;
+}

package/dist/lib/network.d.ts

@@ -0,0 +1,9 @@
+export interface NetworkInfo {
+    latencyMs: number | null;
+    downloadMbps: number | null;
+    uploadMbps: number | null;
+}
+export declare function measureLatency(url: string): Promise<number | null>;
+export declare function estimateDownload(): Promise<number | null>;
+export declare function getNetworkInfo(apiUrl: string): Promise<NetworkInfo>;
+//# sourceMappingURL=network.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"network.d.ts","sourceRoot":"","sources":["../../src/lib/network.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,WAAW;IAC1B,SAAS,EAAE,MAAM,GAAG,IAAI,CAAA;IACxB,YAAY,EAAE,MAAM,GAAG,IAAI,CAAA;IAC3B,UAAU,EAAE,MAAM,GAAG,IAAI,CAAA;CAC1B;AAED,wBAAsB,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CA+BxE;AAED,wBAAsB,gBAAgB,IAAI,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAc/D;AAED,wBAAsB,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC,CAWzE"}

package/dist/lib/network.js

@@ -0,0 +1,62 @@
+import { fetch } from 'undici';
+export async function measureLatency(url) {
+    const samples = [];
+    const attempts = 3;
+    for (let i = 0; i < attempts; i++) {
+        const start = Date.now();
+        try {
+            await fetch(`${url}/api/health/check`, {
+                method: 'GET',
+                signal: AbortSignal.timeout(5000),
+            });
+            samples.push(Date.now() - start);
+        }
+        catch {
+            // Try a fallback HEAD request
+            try {
+                const fallbackStart = Date.now();
+                await fetch(url, {
+                    method: 'HEAD',
+                    signal: AbortSignal.timeout(5000),
+                });
+                samples.push(Date.now() - fallbackStart);
+            }
+            catch { }
+        }
+        // Small delay between samples
+        if (i < attempts - 1)
+            await new Promise(r => setTimeout(r, 200));
+    }
+    if (samples.length === 0)
+        return null;
+    // Use median
+    samples.sort((a, b) => a - b);
+    return samples[Math.floor(samples.length / 2)];
+}
+export async function estimateDownload() {
+    // Download a small fixed payload and estimate throughput
+    const url = 'https://httpbin.org/bytes/524288'; // 512 KB
+    const start = Date.now();
+    try {
+        const res = await fetch(url, { signal: AbortSignal.timeout(10000) });
+        const buffer = await res.arrayBuffer();
+        const elapsed = (Date.now() - start) / 1000;
+        const bytes = buffer.byteLength;
+        const mbps = (bytes * 8) / (elapsed * 1_000_000);
+        return Math.round(mbps * 10) / 10;
+    }
+    catch {
+        return null;
+    }
+}
+export async function getNetworkInfo(apiUrl) {
+    const [latencyMs, downloadMbps] = await Promise.all([
+        measureLatency(apiUrl),
+        estimateDownload(),
+    ]);
+    return {
+        latencyMs,
+        downloadMbps,
+        uploadMbps: null, // upload test not implemented in v1 to avoid large payloads
+    };
+}

package/dist/lib/report.d.ts

@@ -0,0 +1,76 @@
+import type { SystemInfo } from './system.js';
+import type { GpuInfo } from './gpu.js';
+import type { DockerInfo } from './docker.js';
+import type { NetworkInfo } from './network.js';
+export interface ReportData {
+    reportVersion: string;
+    providerWallet: string;
+    resourceName: string;
+    resourceType: string;
+    idleGatewayUrl: string | null;
+    system: SystemInfo;
+    gpu: GpuInfo;
+    docker: DockerInfo;
+    network: NetworkInfo;
+    scores: {
+        gpuScore: number;
+        runtimeScore: number;
+        networkScore: number;
+        inferenceScore: number;
+        stabilityScore: number;
+        finalScore: number;
+        grade: string;
+    };
+    benchmarkMs: number;
+    cliVersion: string;
+}
+export interface FullReport {
+    reportVersion: string;
+    providerWallet: string;
+    resourceName: string;
+    resourceType: string;
+    idleGatewayUrl: string | null;
+    system: {
+        os: string;
+        arch: string;
+        cpuModel: string;
+        cpuCores: number;
+        ramGb: number;
+    };
+    gpu: {
+        name: string | null;
+        vendor: string | null;
+        vramGb: number | null;
+        cudaAvailable: boolean;
+        cudaVersion: string | null;
+        driverVersion: string | null;
+    };
+    runtime: {
+        dockerAvailable: boolean;
+        dockerVersion: string | null;
+        dockerGpuRuntime: boolean;
+    };
+    network: {
+        latencyMs: number | null;
+        downloadMbps: number | null;
+        uploadMbps: number | null;
+    };
+    scores: {
+        gpuScore: number;
+        runtimeScore: number;
+        networkScore: number;
+        inferenceScore: number;
+        stabilityScore: number;
+        finalScore: number;
+        grade: string;
+    };
+    metadata: {
+        createdAt: string;
+        cliVersion: string;
+        benchmarkMs: number;
+    };
+    reportHash: string;
+}
+export declare function buildReport(data: ReportData): FullReport;
+export declare function saveReportLocally(report: FullReport): string;
+//# sourceMappingURL=report.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"report.d.ts","sourceRoot":"","sources":["../../src/lib/report.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAA;AAC7C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,UAAU,CAAA;AACvC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAA;AAC7C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAA;AAE/C,MAAM,WAAW,UAAU;IACzB,aAAa,EAAE,MAAM,CAAA;IACrB,cAAc,EAAE,MAAM,CAAA;IACtB,YAAY,EAAE,MAAM,CAAA;IACpB,YAAY,EAAE,MAAM,CAAA;IACpB,cAAc,EAAE,MAAM,GAAG,IAAI,CAAA;IAC7B,MAAM,EAAE,UAAU,CAAA;IAClB,GAAG,EAAE,OAAO,CAAA;IACZ,MAAM,EAAE,UAAU,CAAA;IAClB,OAAO,EAAE,WAAW,CAAA;IACpB,MAAM,EAAE;QACN,QAAQ,EAAE,MAAM,CAAA;QAChB,YAAY,EAAE,MAAM,CAAA;QACpB,YAAY,EAAE,MAAM,CAAA;QACpB,cAAc,EAAE,MAAM,CAAA;QACtB,cAAc,EAAE,MAAM,CAAA;QACtB,UAAU,EAAE,MAAM,CAAA;QAClB,KAAK,EAAE,MAAM,CAAA;KACd,CAAA;IACD,WAAW,EAAE,MAAM,CAAA;IACnB,UAAU,EAAE,MAAM,CAAA;CACnB;AAED,MAAM,WAAW,UAAU;IACzB,aAAa,EAAE,MAAM,CAAA;IACrB,cAAc,EAAE,MAAM,CAAA;IACtB,YAAY,EAAE,MAAM,CAAA;IACpB,YAAY,EAAE,MAAM,CAAA;IACpB,cAAc,EAAE,MAAM,GAAG,IAAI,CAAA;IAC7B,MAAM,EAAE;QACN,EAAE,EAAE,MAAM,CAAA;QACV,IAAI,EAAE,MAAM,CAAA;QACZ,QAAQ,EAAE,MAAM,CAAA;QAChB,QAAQ,EAAE,MAAM,CAAA;QAChB,KAAK,EAAE,MAAM,CAAA;KACd,CAAA;IACD,GAAG,EAAE;QACH,IAAI,EAAE,MAAM,GAAG,IAAI,CAAA;QACnB,MAAM,EAAE,MAAM,GAAG,IAAI,CAAA;QACrB,MAAM,EAAE,MAAM,GAAG,IAAI,CAAA;QACrB,aAAa,EAAE,OAAO,CAAA;QACtB,WAAW,EAAE,MAAM,GAAG,IAAI,CAAA;QAC1B,aAAa,EAAE,MAAM,GAAG,IAAI,CAAA;KAC7B,CAAA;IACD,OAAO,EAAE;QACP,eAAe,EAAE,OAAO,CAAA;QACxB,aAAa,EAAE,MAAM,GAAG,IAAI,CAAA;QAC5B,gBAAgB,EAAE,OAAO,CAAA;KAC1B,CAAA;IACD,OAAO,EAAE;QACP,SAAS,EAAE,MAAM,GAAG,IAAI,CAAA;QACxB,YAAY,EAAE,MAAM,GAAG,IAAI,CAAA;QAC3B,UAAU,EAAE,MAAM,GAAG,IAAI,CAAA;KAC1B,CAAA;IACD,MAAM,EAAE;QACN,QAAQ,EAAE,MAAM,CAAA;QAChB,YAAY,EAAE,MAAM,CAAA;QACpB,YAAY,EAAE,MAAM,CAAA;QACpB,cAAc,EAAE,MAAM,CAAA;QACtB,cAAc,EAAE,MAAM,CAAA;QACtB,UAAU,EAAE,MAAM,CAAA;QAClB,KAAK,EAAE,MAAM,CAAA;KACd,CAAA;IACD,QAAQ,EAAE;QACR,SAAS,EAAE,MAAM,CAAA;QACjB,UAAU,EAAE,MAAM,CAAA;QAClB,WAAW,EAAE,MAAM,CAAA;KACpB,CAAA;IACD,UAAU,EAAE,MAAM,CAAA;CACnB;AAED,wBAAgB,WAAW,CAAC,IAAI,EAAE,UAAU,GAAG,UAAU,CA6CxD;AAED,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,UAAU,GAAG,MAAM,CAK5D"}

package/dist/lib/report.js

@@ -0,0 +1,53 @@
+import { createHash } from 'crypto';
+import { writeFileSync } from 'fs';
+import { join } from 'path';
+export function buildReport(data) {
+    const reportBody = {
+        reportVersion: data.reportVersion,
+        providerWallet: data.providerWallet,
+        resourceName: data.resourceName,
+        resourceType: data.resourceType,
+        idleGatewayUrl: data.idleGatewayUrl,
+        system: {
+            os: data.system.os,
+            arch: data.system.arch,
+            cpuModel: data.system.cpuModel,
+            cpuCores: data.system.cpuCores,
+            ramGb: data.system.ramGb,
+        },
+        gpu: {
+            name: data.gpu.name,
+            vendor: data.gpu.vendor,
+            vramGb: data.gpu.vramGb,
+            cudaAvailable: data.gpu.cudaAvailable,
+            cudaVersion: data.gpu.cudaVersion,
+            driverVersion: data.gpu.driverVersion,
+        },
+        runtime: {
+            dockerAvailable: data.docker.available,
+            dockerVersion: data.docker.version,
+            dockerGpuRuntime: data.docker.gpuRuntime,
+        },
+        network: {
+            latencyMs: data.network.latencyMs,
+            downloadMbps: data.network.downloadMbps,
+            uploadMbps: data.network.uploadMbps,
+        },
+        scores: data.scores,
+        metadata: {
+            createdAt: new Date().toISOString(),
+            cliVersion: data.cliVersion,
+            benchmarkMs: data.benchmarkMs,
+        },
+    };
+    const reportHash = createHash('sha256')
+        .update(JSON.stringify(reportBody))
+        .digest('hex');
+    return { ...reportBody, reportHash };
+}
+export function saveReportLocally(report) {
+    const filename = `idlebench-report-${Date.now()}.json`;
+    const filepath = join(process.cwd(), filename);
+    writeFileSync(filepath, JSON.stringify(report, null, 2));
+    return filepath;
+}

package/dist/lib/scoring.d.ts

@@ -0,0 +1,24 @@
+export interface ScoreInputs {
+    gpuName?: string | null;
+    vramGb?: number | null;
+    cpuCores: number;
+    ramGb: number;
+    cudaAvailable: boolean;
+    dockerAvailable: boolean;
+    dockerGpuRuntime: boolean;
+    networkLatencyMs?: number | null;
+}
+export declare function calculateGpuScore(inputs: ScoreInputs): number;
+export declare function calculateRuntimeScore(inputs: ScoreInputs): number;
+export declare function calculateNetworkScore(latencyMs?: number | null): number;
+export declare function calculateInferenceScore(cpuCores: number, ramGb: number, benchmarkMs: number, gpuName?: string | null): number;
+export declare function calculateStabilityScore(cpuCores: number, ramGb: number): number;
+export declare function calculateFinalScore(scores: {
+    gpuScore: number;
+    runtimeScore: number;
+    networkScore: number;
+    inferenceScore: number;
+    stabilityScore: number;
+}): number;
+export declare function getGrade(score: number): string;
+//# sourceMappingURL=scoring.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"scoring.d.ts","sourceRoot":"","sources":["../../src/lib/scoring.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,WAAW;IAC1B,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IACvB,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IACtB,QAAQ,EAAE,MAAM,CAAA;IAChB,KAAK,EAAE,MAAM,CAAA;IACb,aAAa,EAAE,OAAO,CAAA;IACtB,eAAe,EAAE,OAAO,CAAA;IACxB,gBAAgB,EAAE,OAAO,CAAA;IACzB,gBAAgB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;CACjC;AAED,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,WAAW,GAAG,MAAM,CAiC7D;AAED,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,WAAW,GAAG,MAAM,CAMjE;AAED,wBAAgB,qBAAqB,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,MAAM,CAUvE;AAED,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,MAAM,CAS7H;AAED,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAQ/E;AAED,wBAAgB,mBAAmB,CAAC,MAAM,EAAE;IAC1C,QAAQ,EAAE,MAAM,CAAA;IAChB,YAAY,EAAE,MAAM,CAAA;IACpB,YAAY,EAAE,MAAM,CAAA;IACpB,cAAc,EAAE,MAAM,CAAA;IACtB,cAAc,EAAE,MAAM,CAAA;CACvB,GAAG,MAAM,CAST;AAED,wBAAgB,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAM9C"}

package/dist/lib/scoring.js

@@ -0,0 +1,125 @@
+export function calculateGpuScore(inputs) {
+    let score = 30;
+    if (inputs.gpuName) {
+        const g = inputs.gpuName.toLowerCase();
+        if (g.includes('h100'))
+            score = 100;
+        else if (g.includes('a100'))
+            score = 99;
+        else if (g.includes('4090'))
+            score = 97;
+        else if (g.includes('4080'))
+            score = 92;
+        else if (g.includes('3090'))
+            score = 88;
+        else if (g.includes('4070'))
+            score = 82;
+        else if (g.includes('3080'))
+            score = 80;
+        else if (g.includes('a6000'))
+            score = 86;
+        else if (g.includes('v100'))
+            score = 82;
+        else if (g.includes('3070'))
+            score = 72;
+        else if (g.includes('t4'))
+            score = 68;
+        else if (g.includes('2080'))
+            score = 68;
+        else if (g.includes('1080'))
+            score = 55;
+        else if (g.includes('amd') || g.includes('radeon') || g.includes('rx'))
+            score = 52;
+        else
+            score = 50;
+    }
+    else {
+        const coreScore = Math.min(40, (inputs.cpuCores / 64) * 40);
+        const ramScore = Math.min(15, (inputs.ramGb / 256) * 15);
+        score = Math.round(coreScore + ramScore);
+    }
+    if (inputs.vramGb) {
+        if (inputs.vramGb >= 40)
+            score = Math.min(100, score + 3);
+        else if (inputs.vramGb >= 24)
+            score = Math.min(100, score + 2);
+        else if (inputs.vramGb >= 16)
+            score = Math.min(100, score + 1);
+    }
+    return Math.max(0, Math.min(100, Math.round(score)));
+}
+export function calculateRuntimeScore(inputs) {
+    let score = 20;
+    if (inputs.dockerAvailable)
+        score += 40;
+    if (inputs.cudaAvailable)
+        score += 25;
+    if (inputs.dockerGpuRuntime)
+        score += 15;
+    return Math.min(100, score);
+}
+export function calculateNetworkScore(latencyMs) {
+    if (!latencyMs || latencyMs <= 0)
+        return 40;
+    if (latencyMs < 20)
+        return 100;
+    if (latencyMs < 50)
+        return 92;
+    if (latencyMs < 100)
+        return 82;
+    if (latencyMs < 150)
+        return 72;
+    if (latencyMs < 200)
+        return 60;
+    if (latencyMs < 400)
+        return 45;
+    if (latencyMs < 600)
+        return 30;
+    return 15;
+}
+export function calculateInferenceScore(cpuCores, ramGb, benchmarkMs, gpuName) {
+    let base = 50;
+    if (gpuName)
+        base += 20;
+    base += Math.min(15, cpuCores / 3);
+    base += Math.min(10, ramGb / 32);
+    // Faster benchmark = better score
+    if (benchmarkMs < 200)
+        base += 5;
+    else if (benchmarkMs > 2000)
+        base -= 10;
+    return Math.min(100, Math.max(0, Math.round(base)));
+}
+export function calculateStabilityScore(cpuCores, ramGb) {
+    let score = 75;
+    if (cpuCores >= 8)
+        score += 5;
+    if (cpuCores >= 16)
+        score += 5;
+    if (ramGb >= 16)
+        score += 5;
+    if (ramGb >= 32)
+        score += 5;
+    if (ramGb >= 64)
+        score += 5;
+    return Math.min(100, score);
+}
+export function calculateFinalScore(scores) {
+    const final = scores.gpuScore * 0.3 +
+        scores.runtimeScore * 0.2 +
+        scores.inferenceScore * 0.2 +
+        scores.networkScore * 0.15 +
+        scores.stabilityScore * 0.15;
+    return Math.max(0, Math.min(100, Math.round(final)));
+}
+export function getGrade(score) {
+    if (score >= 95)
+        return 'Elite';
+    if (score >= 85)
+        return 'Verified A';
+    if (score >= 70)
+        return 'Verified B';
+    if (score >= 55)
+        return 'Risky';
+    return 'Not Recommended';
+}

package/dist/lib/system.d.ts

@@ -0,0 +1,10 @@
+export interface SystemInfo {
+    os: string;
+    arch: string;
+    cpuModel: string;
+    cpuCores: number;
+    ramGb: number;
+    platform: string;
+}
+export declare function getSystemInfo(): Promise<SystemInfo>;
+//# sourceMappingURL=system.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"system.d.ts","sourceRoot":"","sources":["../../src/lib/system.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,UAAU;IACzB,EAAE,EAAE,MAAM,CAAA;IACV,IAAI,EAAE,MAAM,CAAA;IACZ,QAAQ,EAAE,MAAM,CAAA;IAChB,QAAQ,EAAE,MAAM,CAAA;IAChB,KAAK,EAAE,MAAM,CAAA;IACb,QAAQ,EAAE,MAAM,CAAA;CACjB;AAED,wBAAsB,aAAa,IAAI,OAAO,CAAC,UAAU,CAAC,CAmBzD"}