badgr-cli 1.1.1 → 1.1.2

package/tests/gpu-doctor-doctor.test.js

@@ -1,304 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-import { runGpuDoctor } from '../src/gpuDoctor/doctor.js';
-
-let tmpFiles;
-
-beforeEach(() => { tmpFiles = []; });
-afterEach(() => {
-  for (const f of tmpFiles) fs.rmSync(f, { recursive: true, force: true });
-});
-
-function tmpFile(name, content) {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'gpu-doctor-'));
-  const file = path.join(dir, name);
-  fs.writeFileSync(file, content);
-  tmpFiles.push(dir);
-  return file;
-}
-
-const noGpuEnv = {
-  detectGpus: () => ({ available: false, error: 'nvidia-smi not found', driverVersion: null, cudaVersion: null, gpus: [], processes: [] }),
-  detectTorch: () => ({ pythonAvailable: false, torchInstalled: false, cudaAvailable: false, error: 'python not found' }),
-  detectDisk: () => ({ cachePath: '/tmp/hf', cacheSource: 'default', cacheExists: false, writable: true, freeGb: 100, totalGb: 500 }),
-};
-
-const gpuNoCudaEnv = {
-  detectGpus: () => ({
-    available: true,
-    driverVersion: '535.104.05',
-    cudaVersion: '12.2',
-    gpus: [{ index: 0, name: 'NVIDIA GeForce RTX 4090', vramTotalGb: 24, vramFreeGb: 23.1, vramUsedGb: 0.9, temperatureC: 40, powerDrawW: 30 }],
-    processes: [],
-  }),
-  detectTorch: () => ({ pythonAvailable: true, pythonBinary: 'python3', torchInstalled: true, cudaAvailable: false, cudaVersion: null, deviceName: null, error: null }),
-  detectDisk: () => ({ cachePath: '/tmp/hf', cacheSource: 'default', cacheExists: true, writable: true, freeGb: 100, totalGb: 500 }),
-};
-
-const gpu24Env = {
-  detectGpus: () => ({
-    available: true,
-    driverVersion: '550.54.15',
-    cudaVersion: '12.4',
-    gpus: [{ index: 0, name: 'NVIDIA GeForce RTX 4090', vramTotalGb: 24, vramFreeGb: 18.6, vramUsedGb: 5.4, temperatureC: 45, powerDrawW: 120 }],
-    processes: [],
-  }),
-  detectTorch: () => ({ pythonAvailable: true, pythonBinary: 'python3', torchInstalled: true, cudaAvailable: true, cudaVersion: '12.4', deviceName: 'NVIDIA GeForce RTX 4090', error: null }),
-  detectDisk: () => ({ cachePath: '/tmp/hf', cacheSource: 'default', cacheExists: true, writable: true, freeGb: 100, totalGb: 500 }),
-};
-
-describe('Scenario 1 — no NVIDIA GPU', () => {
-  it('reports no GPU detected without crashing, exit-worthy verdict only (not an error)', async () => {
-    const report = await runGpuDoctor({}, noGpuEnv);
-    expect(report.verdict).toBe('no NVIDIA GPU detected');
-    expect(report.verdictSlug).toBe('no_gpu_detected');
-    expect(report.likelyCause).toMatch(/GPU unavailable|not passed into the container/);
-    expect(report.suggestedFixes.some((f) => /Docker|NVIDIA Container Toolkit|badgr serve/.test(f))).toBe(true);
-  });
-});
-
-describe('Scenario 2 — GPU exists but PyTorch cannot use CUDA', () => {
-  it('reports CUDA visible to system but not to PyTorch', async () => {
-    const report = await runGpuDoctor({}, gpuNoCudaEnv);
-    expect(report.verdict).toBe('CUDA visible to system but not to PyTorch');
-    expect(report.verdictSlug).toBe('cuda_not_visible_to_pytorch');
-    expect(report.likelyCause).toMatch(/CPU-only torch wheel|CUDA runtime|container/);
-  });
-});
-
-describe('Scenario 3 — vLLM OOM log', () => {
-  it('reports likely fail / vram_oom for a vLLM OOM log', async () => {
-    const logFile = tmpFile('vllm-oom.log', [
-      'torch.cuda.OutOfMemoryError: CUDA out of memory. Tried to allocate 2.00 GiB',
-      'ERROR: EngineDeadError: engine core process died',
-      'ERROR: worker died',
-    ].join('\n'));
-    const report = await runGpuDoctor({ logsPath: logFile }, noGpuEnv);
-    expect(report.verdict).toBe('likely fail');
-    expect(report.category).toBe('vram_oom');
-    expect(report.suggestedFixes.length).toBeGreaterThan(0);
-  });
-});
-
-describe('Scenario 4 — model too large for GPU', () => {
-  it('reports likely fail and recommends an 80GB+ class GPU on a 24GB card', async () => {
-    const report = await runGpuDoctor({ model: 'meta-llama/Llama-3.1-70B-Instruct', serve: true }, gpu24Env);
-    expect(report.verdict).toBe('likely fail');
-    expect(report.category).toBe('model_too_large');
-    expect(report.suggestedFixes.some((f) => /80GB\+|multi-GPU/.test(f))).toBe(true);
-  });
-});
-
-describe('Scenario 5 — small model likely fits', () => {
-  it('reports likely okay with conservative settings on a 24GB card', async () => {
-    const report = await runGpuDoctor({ model: 'Qwen/Qwen2.5-7B-Instruct', serve: true }, gpu24Env);
-    expect(report.verdict).toBe('likely okay with conservative settings');
-    expect(report.suggestedFixes.some((f) => /max model length/i.test(f))).toBe(true);
-  });
-});
-
-describe('Scenario 6 — Comfy workflow with missing model names', () => {
-  it('detects SDXL, referenced models, and custom nodes', async () => {
-    const workflowFile = tmpFile('sdxl-workflow.json', JSON.stringify({
-      1: { class_type: 'CheckpointLoaderSimple', inputs: { ckpt_name: 'sd_xl_base_1.0.safetensors' } },
-      2: { class_type: 'KSampler', inputs: {} },
-      3: { class_type: 'ImpactWildcardEncode', inputs: {} },
-    }));
-    const report = await runGpuDoctor({ workflowPath: workflowFile }, noGpuEnv);
-    expect(report.category).toBe('comfy_workflow');
-    expect(report.evidence.some((e) => /likely SDXL/.test(e))).toBe(true);
-    expect(report.evidence.some((e) => /sd_xl_base_1\.0\.safetensors/.test(e))).toBe(true);
-    expect(report.evidence.some((e) => /ImpactWildcardEncode/.test(e))).toBe(true);
-  });
-});
-
-describe('Scenario 7 — endpoint health check fails', () => {
-  it('reports endpoint not reachable on connection refused', async () => {
-    const err = new Error('fetch failed');
-    err.cause = { code: 'ECONNREFUSED' };
-    const fetchImpl = async () => { throw err; };
-    const report = await runGpuDoctor({ url: 'http://localhost:8000/v1/models' }, { ...noGpuEnv, fetchImpl });
-    expect(report.verdict).toBe('endpoint not reachable');
-    expect(report.category).toBe('endpoint_health');
-    expect(report.likelyCause).toMatch(/not started|port|health check/);
-  });
-});
-
-describe('Scenario 8 — JSON-shape report fields', () => {
-  it('includes verdict, category, evidence, suggested fixes, and badgr command', async () => {
-    const logFile = tmpFile('vllm-oom.log', 'CUDA out of memory');
-    const report = await runGpuDoctor({ logsPath: logFile }, noGpuEnv);
-    expect(report).toMatchObject({
-      verdictSlug: 'likely_fail',
-      category: 'vram_oom',
-    });
-    expect(Array.isArray(report.evidence)).toBe(true);
-    expect(Array.isArray(report.suggestedFixes)).toBe(true);
-    expect('badgrCommand' in report).toBe(true);
-  });
-});
-
-describe('tool errors — missing files', () => {
-  it('throws (does not silently succeed) when --logs points at a missing file', async () => {
-    await expect(runGpuDoctor({ logsPath: '/nonexistent/path.log' }, noGpuEnv)).rejects.toThrow();
-  });
-
-  it('throws when --workflow points at a missing file', async () => {
-    await expect(runGpuDoctor({ workflowPath: '/nonexistent/workflow.json' }, noGpuEnv)).rejects.toThrow();
-  });
-
-  it('throws on invalid workflow JSON', async () => {
-    const badFile = tmpFile('bad.json', 'not valid json');
-    await expect(runGpuDoctor({ workflowPath: badFile }, noGpuEnv)).rejects.toThrow();
-  });
-});
-
-describe('no GPU exists — still gives useful output', () => {
-  it('never throws for the default no-GPU baseline invocation', async () => {
-    await expect(runGpuDoctor({}, noGpuEnv)).resolves.toBeTruthy();
-  });
-});
-
-describe('non-NVIDIA system — nvidia-smi errors that are not ENOENT', () => {
-  it('reports no GPU detected without crashing on a generic exec failure', async () => {
-    const env = {
-      detectGpus: () => ({ available: false, error: 'permission denied', driverVersion: null, cudaVersion: null, gpus: [], processes: [] }),
-      detectTorch: () => ({ pythonAvailable: true, pythonBinary: 'python3', torchInstalled: false, cudaAvailable: false, error: null }),
-      detectDisk: () => ({ cachePath: '/tmp/hf', cacheSource: 'default', cacheExists: true, writable: true, freeGb: 100, totalGb: 500 }),
-    };
-    const report = await runGpuDoctor({}, env);
-    expect(report.verdict).toBe('no NVIDIA GPU detected');
-  });
-});
-
-describe('missing Python — torch probe unavailable', () => {
-  it('still reports a GPU-visible baseline without crashing when python is not found', async () => {
-    const env = {
-      detectGpus: () => gpu24Env.detectGpus(),
-      detectTorch: () => ({ pythonAvailable: false, pythonBinary: null, torchInstalled: false, cudaAvailable: false, error: 'python not found' }),
-      detectDisk: () => ({ cachePath: '/tmp/hf', cacheSource: 'default', cacheExists: true, writable: true, freeGb: 100, totalGb: 500 }),
-    };
-    const report = await runGpuDoctor({}, env);
-    expect(report.verdict).toBe('GPU visible but PyTorch not installed');
-    expect(report.evidence.some((e) => /PyTorch: not installed/.test(e))).toBe(true);
-  });
-});
-
-describe('multiple GPUs', () => {
-  it('picks the GPU with the most free VRAM when sizing a model', async () => {
-    const env = {
-      detectGpus: () => ({
-        available: true,
-        driverVersion: '550.54.15',
-        cudaVersion: '12.4',
-        gpus: [
-          { index: 0, name: 'NVIDIA A100', vramTotalGb: 40, vramFreeGb: 2.1, vramUsedGb: 37.9, temperatureC: 60, powerDrawW: 200 },
-          { index: 1, name: 'NVIDIA A100', vramTotalGb: 40, vramFreeGb: 38.5, vramUsedGb: 1.5, temperatureC: 45, powerDrawW: 90 },
-        ],
-        processes: [],
-      }),
-      detectTorch: () => ({ pythonAvailable: true, pythonBinary: 'python3', torchInstalled: true, cudaAvailable: true, cudaVersion: '12.4', deviceName: 'NVIDIA A100', error: null }),
-      detectDisk: () => ({ cachePath: '/tmp/hf', cacheSource: 'default', cacheExists: true, writable: true, freeGb: 100, totalGb: 500 }),
-    };
-    const report = await runGpuDoctor({ model: 'meta-llama/Llama-3.1-8B-Instruct', serve: true }, env);
-    expect(report.evidence.some((e) => /GPU 0:/.test(e))).toBe(true);
-    expect(report.evidence.some((e) => /GPU 1:/.test(e))).toBe(true);
-    expect(report.evidence.some((e) => /Available VRAM: 38.5GB/.test(e))).toBe(true);
-  });
-});
-
-describe('unrecognized --gpu name degrades to insufficient data', () => {
-  it('does not fabricate a confident verdict for an unknown GPU with no local GPU present', async () => {
-    const report = await runGpuDoctor({ model: 'Qwen/Qwen2.5-7B-Instruct', gpu: 'NotARealGpu9000' }, noGpuEnv);
-    expect(report.verdictSlug).toBe('insufficient_data');
-    expect(report.evidence.some((e) => /not recognized/.test(e))).toBe(true);
-  });
-});
-
-describe('source-priority note', () => {
-  it('records which input was selected and which were ignored when multiple are given', async () => {
-    const logFile = tmpFile('vllm-oom.log', 'CUDA out of memory');
-    const report = await runGpuDoctor({ logsPath: logFile, model: 'Qwen/Qwen2.5-7B-Instruct', url: 'http://localhost:8000' }, noGpuEnv);
-    expect(report.evidence[0]).toMatch(/^Diagnosing from: --logs/);
-    expect(report.evidence.some((e) => /^Ignored/.test(e) && /--url/.test(e) && /--model/.test(e))).toBe(true);
-  });
-
-  it('notes baseline diagnosis when no source flags are given', async () => {
-    const report = await runGpuDoctor({}, noGpuEnv);
-    expect(report.evidence[0]).toMatch(/^Diagnosing from: baseline/);
-  });
-});
-
-describe('multi-GPU model fit (--gpu-count)', () => {
-  const twoA100Env = {
-    detectGpus: () => ({
-      available: true,
-      driverVersion: '550.54.15',
-      cudaVersion: '12.4',
-      gpus: [
-        { index: 0, name: 'NVIDIA A100', vramTotalGb: 80, vramFreeGb: 78, vramUsedGb: 2, temperatureC: 45, powerDrawW: 90 },
-        { index: 1, name: 'NVIDIA A100', vramTotalGb: 80, vramFreeGb: 40, vramUsedGb: 40, temperatureC: 50, powerDrawW: 110 },
-      ],
-      processes: [],
-    }),
-    detectTorch: () => ({ pythonAvailable: true, pythonBinary: 'python3', torchInstalled: true, cudaAvailable: true, cudaVersion: '12.4', deviceName: 'NVIDIA A100', error: null }),
-    detectDisk: () => ({ cachePath: '/tmp/hf', cacheSource: 'default', cacheExists: true, writable: true, freeGb: 100, totalGb: 500 }),
-  };
-
-  it('a 70B-AWQ model that fails on one 24GB GPU fits once split across 2 GPUs', async () => {
-    const single = await runGpuDoctor({ model: 'meta-llama/Llama-3.1-70B-Instruct-AWQ', serve: true }, gpu24Env);
-    expect(single.verdict).toBe('likely fail');
-
-    const dual = await runGpuDoctor({ model: 'meta-llama/Llama-3.1-70B-Instruct-AWQ', serve: true, gpuCount: 2 }, twoA100Env);
-    expect(dual.category).not.toBe('model_too_large');
-    expect(dual.evidence.some((e) => /GPU count: 2 \(tensor-parallel\)/.test(e))).toBe(true);
-    expect(dual.evidence.some((e) => /per GPU/.test(e))).toBe(true);
-  });
-
-  it('sizes against the weaker of the requested GPUs, not the strongest', async () => {
-    const dual = await runGpuDoctor({ model: 'meta-llama/Llama-3.1-70B-Instruct-AWQ', serve: true, gpuCount: 2 }, twoA100Env);
-    expect(dual.evidence.some((e) => /Available VRAM: 40GB per GPU/.test(e))).toBe(true);
-  });
-
-  it('flags when fewer physical GPUs are detected than requested', async () => {
-    const report = await runGpuDoctor({ model: 'meta-llama/Llama-3.1-8B-Instruct', serve: true, gpuCount: 4 }, gpu24Env);
-    expect(report.evidence.some((e) => /Only 1 local GPU\(s\) detected — fewer than the 4 requested/.test(e))).toBe(true);
-  });
-
-  it('defaults to a single-GPU estimate when --gpu-count is omitted', async () => {
-    const report = await runGpuDoctor({ model: 'Qwen/Qwen2.5-7B-Instruct', serve: true }, gpu24Env);
-    expect(report.evidence.some((e) => /per GPU/.test(e))).toBe(false);
-    expect(report.evidence.some((e) => /GPU count:/.test(e))).toBe(false);
-  });
-});
-
-describe('endpoint health — non-OpenAI formats', () => {
-  it('recognizes a ComfyUI /system_stats response', async () => {
-    const fetchImpl = async () => new Response(JSON.stringify({ system: {}, devices: [{ name: 'cuda:0' }] }), { status: 200 });
-    const report = await runGpuDoctor({ url: 'http://localhost:8188/system_stats' }, { ...noGpuEnv, fetchImpl });
-    expect(report.verdict).toBe('endpoint ready');
-    expect(report.evidence.some((e) => /ComfyUI system stats — 1 device\(s\) reported/.test(e))).toBe(true);
-  });
-
-  it('recognizes a llama.cpp-style {status: "..."} health response', async () => {
-    const fetchImpl = async () => new Response(JSON.stringify({ status: 'ok' }), { status: 200 });
-    const report = await runGpuDoctor({ url: 'http://localhost:8080/health' }, { ...noGpuEnv, fetchImpl });
-    expect(report.verdict).toBe('endpoint ready');
-    expect(report.evidence.some((e) => /status: ok/.test(e))).toBe(true);
-  });
-
-  it('recognizes a bare-text "OK" health response', async () => {
-    const fetchImpl = async () => new Response('OK', { status: 200 });
-    const report = await runGpuDoctor({ url: 'http://localhost:9000/healthz' }, { ...noGpuEnv, fetchImpl });
-    expect(report.verdict).toBe('endpoint ready');
-    expect(report.evidence.some((e) => /response: OK/.test(e))).toBe(true);
-  });
-
-  it('still reports the OpenAI-style model count for /v1/models', async () => {
-    const fetchImpl = async () => new Response(JSON.stringify({ data: [{ id: 'a' }, { id: 'b' }] }), { status: 200 });
-    const report = await runGpuDoctor({ url: 'http://localhost:8000/v1/models' }, { ...noGpuEnv, fetchImpl });
-    expect(report.evidence.some((e) => /\/v1\/models reports 2 model\(s\)/.test(e))).toBe(true);
-  });
-});

package/tests/gpu-doctor-probe-cache.test.js

@@ -1,110 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { readProbeCache, writeProbeCache } from '../src/gpuDoctor/probeCache.js';
-import { collectEnvironment } from '../src/gpuDoctor/doctor.js';
-
-function memoryFs() {
-  let contents;
-  return {
-    readFileSync: () => {
-      if (contents === undefined) {
-        const err = new Error('ENOENT');
-        err.code = 'ENOENT';
-        throw err;
-      }
-      return contents;
-    },
-    writeFileSync: (_path, data) => { contents = data; },
-  };
-}
-
-describe('probeCache', () => {
-  it('is a miss when nothing has been written yet', () => {
-    const fsImpl = memoryFs();
-    expect(readProbeCache('gpu', { fsImpl })).toBeUndefined();
-  });
-
-  it('returns a written value within the TTL window', () => {
-    const fsImpl = memoryFs();
-    writeProbeCache('gpu', { available: true }, { fsImpl });
-    expect(readProbeCache('gpu', { fsImpl, ttlMs: 10_000 })).toEqual({ available: true });
-  });
-
-  it('expires a value once the TTL has elapsed', () => {
-    const fsImpl = memoryFs();
-    writeProbeCache('gpu', { available: true }, { fsImpl });
-    expect(readProbeCache('gpu', { fsImpl, ttlMs: -1 })).toBeUndefined();
-  });
-
-  it('keeps separate entries per key in the same store', () => {
-    const fsImpl = memoryFs();
-    writeProbeCache('gpu', { a: 1 }, { fsImpl });
-    writeProbeCache('torch', { b: 2 }, { fsImpl });
-    expect(readProbeCache('gpu', { fsImpl })).toEqual({ a: 1 });
-    expect(readProbeCache('torch', { fsImpl })).toEqual({ b: 2 });
-  });
-
-  it('degrades to a miss instead of throwing when the store is corrupt', () => {
-    const fsImpl = { readFileSync: () => 'not json', writeFileSync: () => {} };
-    expect(() => readProbeCache('gpu', { fsImpl })).not.toThrow();
-    expect(readProbeCache('gpu', { fsImpl })).toBeUndefined();
-  });
-
-  it('never throws even when the filesystem write fails', () => {
-    const fsImpl = {
-      readFileSync: () => { throw new Error('ENOENT'); },
-      writeFileSync: () => { throw new Error('EACCES'); },
-    };
-    expect(() => writeProbeCache('gpu', { available: true }, { fsImpl })).not.toThrow();
-  });
-});
-
-describe('collectEnvironment — probe caching', () => {
-  it('bypasses the cache entirely when deps.detectGpus/detectTorch are injected', () => {
-    const fsImpl = memoryFs();
-    // Pre-populate the cache with a decoy value the injected fakes must not return.
-    writeProbeCache('gpu', { available: false, decoy: true }, { fsImpl });
-    const realGpu = { available: true, gpus: [{ index: 0, name: 'stub', vramTotalGb: 24, vramFreeGb: 20 }] };
-    const env = collectEnvironment({
-      detectGpus: () => realGpu,
-      detectTorch: () => ({ torchInstalled: true }),
-      detectDisk: () => ({ cachePath: '/x', cacheSource: 'x', cacheExists: true, writable: true }),
-      cacheFsImpl: fsImpl,
-    });
-    expect(env.gpu).toBe(realGpu);
-  });
-
-  it('reuses a cached result for the real (non-injected) probe path instead of running the probe again', () => {
-    const fsImpl = memoryFs();
-    const cachedGpu = { available: true, gpus: [{ index: 0, name: 'cached-gpu' }] };
-    const cachedTorch = { torchInstalled: true, cudaAvailable: true };
-    writeProbeCache('gpu', cachedGpu, { fsImpl });
-    writeProbeCache('torch', cachedTorch, { fsImpl });
-
-    // No deps.detectGpus/detectTorch here — this exercises the real-probe
-    // branch, which must consult the cache before shelling out.
-    const env = collectEnvironment({
-      cacheFsImpl: fsImpl,
-      cacheTtlMs: 60_000,
-      detectDisk: () => ({ cachePath: '/x', cacheSource: 'x', cacheExists: true, writable: true }),
-    });
-
-    expect(env.gpu).toEqual(cachedGpu);
-    expect(env.torch).toEqual(cachedTorch);
-  });
-
-  it('forces fresh probes when deps.noCache is set, even with a warm cache', () => {
-    const fsImpl = memoryFs();
-    writeProbeCache('gpu', { available: false, decoy: true }, { fsImpl });
-    let probeCalls = 0;
-    const freshGpu = { available: true, calls: 0 };
-    const env = collectEnvironment({
-      noCache: true,
-      cacheFsImpl: fsImpl,
-      detectGpus: () => { probeCalls += 1; return freshGpu; },
-      detectTorch: () => ({ torchInstalled: true }),
-      detectDisk: () => ({ cachePath: '/x', cacheSource: 'x', cacheExists: true, writable: true }),
-    });
-    expect(env.gpu).toBe(freshGpu);
-    expect(probeCalls).toBe(1);
-  });
-});

package/tests/gpu-doctor-probes.test.js

@@ -1,257 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { detectGpus } from '../src/gpuDoctor/gpuInfo.js';
-import { detectTorch } from '../src/gpuDoctor/torchInfo.js';
-import { detectDisk } from '../src/gpuDoctor/diskInfo.js';
-import { collectEnvironment } from '../src/gpuDoctor/doctor.js';
-
-function enoent() {
-  const err = new Error('spawn ENOENT');
-  err.code = 'ENOENT';
-  return err;
-}
-
-describe('detectGpus', () => {
-  it('reports unavailable with "nvidia-smi not found" on ENOENT', () => {
-    const exec = () => { throw enoent(); };
-    const result = detectGpus(exec);
-    expect(result.available).toBe(false);
-    expect(result.error).toBe('nvidia-smi not found');
-    expect(result.gpus).toEqual([]);
-  });
-
-  it('reports unavailable with the raw error message on a non-ENOENT failure', () => {
-    const exec = () => { throw new Error('permission denied'); };
-    const result = detectGpus(exec);
-    expect(result.available).toBe(false);
-    expect(result.error).toBe('permission denied');
-  });
-
-  it('parses driver version, CUDA version, and a single GPU from real nvidia-smi output shapes', () => {
-    const plainText = `Wed Jul 16 08:00:00 2026
-+-----------------------------------------------------------------------------+
-| NVIDIA-SMI 550.54.15    Driver Version: 550.54.15    CUDA Version: 12.4     |
-+-------------------------------+----------------------+----------------------+`;
-    const csv = '0, NVIDIA GeForce RTX 4090, 24564, 19022, 5542, 45, 120.5';
-    const exec = (cmd, args) => {
-      if (!args || args.length === 0) return plainText;
-      if (args[0].includes('query-gpu')) return csv;
-      if (args[0].includes('query-compute-apps')) return '';
-      throw new Error('unexpected args');
-    };
-    const result = detectGpus(exec);
-    expect(result.available).toBe(true);
-    expect(result.driverVersion).toBe('550.54.15');
-    expect(result.cudaVersion).toBe('12.4');
-    expect(result.gpus).toHaveLength(1);
-    expect(result.gpus[0]).toMatchObject({ index: 0, name: 'NVIDIA GeForce RTX 4090' });
-    expect(result.gpus[0].vramTotalGb).toBeCloseTo(24, 0);
-    expect(result.gpus[0].vramFreeGb).toBeCloseTo(18.6, 0);
-  });
-
-  it('parses multiple GPUs from multi-line CSV output', () => {
-    const csv = [
-      '0, NVIDIA A100, 40960, 2150, 38810, 60, 200',
-      '1, NVIDIA A100, 40960, 39424, 1536, 45, 90',
-    ].join('\n');
-    const exec = (cmd, args) => {
-      if (!args || args.length === 0) return 'Driver Version: 535.104.05    CUDA Version: 12.2';
-      if (args[0].includes('query-gpu')) return csv;
-      return '';
-    };
-    const result = detectGpus(exec);
-    expect(result.gpus).toHaveLength(2);
-    expect(result.gpus.map((g) => g.index)).toEqual([0, 1]);
-    expect(result.gpus[1].vramFreeGb).toBeGreaterThan(result.gpus[0].vramFreeGb);
-  });
-
-  it('parses compute-apps processes and handles [N/A] temperature/power', () => {
-    const gpuCsv = '0, NVIDIA T4, 16384, 16000, 384, [N/A], [N/A]';
-    const procCsv = '1234, python, 2048\n5678, vllm-worker, 4096';
-    const exec = (cmd, args) => {
-      if (!args || args.length === 0) return 'Driver Version: 470.199.02    CUDA Version: 11.4';
-      if (args[0].includes('query-gpu')) return gpuCsv;
-      if (args[0].includes('query-compute-apps')) return procCsv;
-      return '';
-    };
-    const result = detectGpus(exec);
-    expect(result.gpus[0].temperatureC).toBeNull();
-    expect(result.gpus[0].powerDrawW).toBeNull();
-    expect(result.processes).toHaveLength(2);
-    expect(result.processes[0]).toEqual({ pid: 1234, name: 'python', memoryMb: 2048 });
-  });
-
-  it('still reports available=true when the CSV query is unsupported but the plain probe succeeded', () => {
-    const exec = (cmd, args) => {
-      if (!args || args.length === 0) return 'Driver Version: 550.54.15    CUDA Version: 12.4';
-      throw new Error('unsupported field');
-    };
-    const result = detectGpus(exec);
-    expect(result.available).toBe(true);
-    expect(result.driverVersion).toBe('550.54.15');
-    expect(result.gpus).toEqual([]);
-    expect(result.processes).toEqual([]);
-  });
-});
-
-describe('detectTorch', () => {
-  it('parses a successful python3 probe result', () => {
-    const payload = JSON.stringify({
-      torchInstalled: true, cudaAvailable: true, cudaVersion: '12.4',
-      deviceName: 'NVIDIA GeForce RTX 4090', deviceCount: 1,
-      freeVramGb: 18.6, totalVramGb: 24.0, error: null,
-    });
-    const exec = (bin) => {
-      if (bin === 'python3') return payload + '\n';
-      throw enoent();
-    };
-    const result = detectTorch(exec);
-    expect(result.pythonAvailable).toBe(true);
-    expect(result.pythonBinary).toBe('python3');
-    expect(result.cudaAvailable).toBe(true);
-    expect(result.deviceName).toBe('NVIDIA GeForce RTX 4090');
-  });
-
-  it('falls back to "python" when "python3" is not found', () => {
-    const payload = JSON.stringify({ torchInstalled: false, cudaAvailable: false, error: null });
-    const exec = (bin) => {
-      if (bin === 'python3') throw enoent();
-      if (bin === 'python') return payload;
-      throw new Error('unexpected binary');
-    };
-    const result = detectTorch(exec);
-    expect(result.pythonAvailable).toBe(true);
-    expect(result.pythonBinary).toBe('python');
-  });
-
-  it('reports "python not found" when neither binary exists', () => {
-    const exec = () => { throw enoent(); };
-    const result = detectTorch(exec);
-    expect(result.pythonAvailable).toBe(false);
-    expect(result.pythonBinary).toBeNull();
-    expect(result.error).toBe('python not found');
-  });
-
-  it('reports pythonAvailable=true but torchInstalled=false when python exists but the probe output cannot be parsed', () => {
-    const exec = () => { throw new Error('SyntaxError: invalid syntax'); };
-    const result = detectTorch(exec);
-    expect(result.pythonAvailable).toBe(true);
-    expect(result.torchInstalled).toBe(false);
-    expect(result.error).toBe('could not read torch probe output');
-  });
-
-  it('reads the last line of output when extra warning lines precede the JSON', () => {
-    const payload = JSON.stringify({ torchInstalled: true, cudaAvailable: false, error: null });
-    const exec = () => `FutureWarning: something is deprecated\n${payload}`;
-    const result = detectTorch(exec);
-    expect(result.torchInstalled).toBe(true);
-    expect(result.cudaAvailable).toBe(false);
-  });
-
-  it('falls through to the next binary when output is not valid JSON', () => {
-    const payload = JSON.stringify({ torchInstalled: true, cudaAvailable: true, error: null });
-    const exec = (bin) => {
-      if (bin === 'python3') return 'not json at all';
-      if (bin === 'python') return payload;
-      throw new Error('unexpected');
-    };
-    const result = detectTorch(exec);
-    expect(result.pythonBinary).toBe('python');
-    expect(result.cudaAvailable).toBe(true);
-  });
-});
-
-describe('detectDisk', () => {
-  const ORIGINAL_ENV = { ...process.env };
-
-  beforeEach(() => {
-    delete process.env.HF_HOME;
-    delete process.env.HUGGINGFACE_HUB_CACHE;
-  });
-
-  afterEach(() => {
-    process.env = { ...ORIGINAL_ENV };
-  });
-
-  it('uses HF_HOME when set, and reports it as the source', () => {
-    process.env.HF_HOME = '/custom/hf-cache';
-    const fsImpl = {
-      existsSync: (p) => p === '/custom/hf-cache',
-      statfsSync: () => ({ bavail: 1000, bsize: 4096, blocks: 5000 }),
-      accessSync: () => {},
-    };
-    const result = detectDisk(fsImpl);
-    expect(result.cachePath).toBe('/custom/hf-cache');
-    expect(result.cacheSource).toBe('HF_HOME');
-    expect(result.cacheExists).toBe(true);
-  });
-
-  it('falls back to HUGGINGFACE_HUB_CACHE when HF_HOME is unset', () => {
-    process.env.HUGGINGFACE_HUB_CACHE = '/other/cache';
-    const fsImpl = { existsSync: () => false, statfsSync: () => { throw new Error('no'); }, accessSync: () => {} };
-    const result = detectDisk(fsImpl);
-    expect(result.cachePath).toBe('/other/cache');
-    expect(result.cacheSource).toBe('HUGGINGFACE_HUB_CACHE');
-  });
-
-  it('computes freeGb/totalGb from statfsSync fields', () => {
-    const fsImpl = {
-      existsSync: () => true,
-      statfsSync: () => ({ bavail: 2_000_000, bsize: 4096, blocks: 10_000_000 }),
-      accessSync: () => {},
-    };
-    const result = detectDisk(fsImpl);
-    expect(result.freeGb).toBeCloseTo((2_000_000 * 4096) / 1e9, 1);
-    expect(result.totalGb).toBeCloseTo((10_000_000 * 4096) / 1e9, 1);
-  });
-
-  it('leaves freeGb/totalGb null when statfsSync is unsupported, without throwing', () => {
-    const fsImpl = { existsSync: () => true, statfsSync: () => { throw new Error('ENOSYS'); }, accessSync: () => {} };
-    const result = detectDisk(fsImpl);
-    expect(result.freeGb).toBeNull();
-    expect(result.totalGb).toBeNull();
-  });
-
-  it('reports writable=false when accessSync throws (read-only path)', () => {
-    const fsImpl = {
-      existsSync: () => true,
-      statfsSync: () => ({ bavail: 1, bsize: 4096, blocks: 1 }),
-      accessSync: () => { throw new Error('EACCES'); },
-    };
-    const result = detectDisk(fsImpl);
-    expect(result.writable).toBe(false);
-  });
-
-  it('reports writable=true when accessSync succeeds', () => {
-    const fsImpl = {
-      existsSync: () => true,
-      statfsSync: () => ({ bavail: 1, bsize: 4096, blocks: 1 }),
-      accessSync: () => {},
-    };
-    const result = detectDisk(fsImpl);
-    expect(result.writable).toBe(true);
-  });
-});
-
-describe('collectEnvironment', () => {
-  it('wires deps.detectGpus/detectTorch/detectDisk overrides through to the returned env', () => {
-    const gpu = { available: true, gpus: [{ index: 0, name: 'stub-gpu', vramTotalGb: 24, vramFreeGb: 20 }], processes: [], driverVersion: '1.0', cudaVersion: '12.0', error: null };
-    const torch = { pythonAvailable: true, pythonBinary: 'python3', torchInstalled: true, cudaAvailable: true, error: null };
-    const disk = { cachePath: '/stub', cacheSource: 'stub', cacheExists: true, writable: true, freeGb: 10, totalGb: 20 };
-    const env = collectEnvironment({
-      detectGpus: () => gpu,
-      detectTorch: () => torch,
-      detectDisk: () => disk,
-    });
-    expect(env.gpu).toBe(gpu);
-    expect(env.torch).toBe(torch);
-    expect(env.disk).toBe(disk);
-  });
-
-  it('falls back to the real probe modules when no deps are given, without throwing', () => {
-    expect(() => collectEnvironment()).not.toThrow();
-    const env = collectEnvironment();
-    expect(env).toHaveProperty('gpu');
-    expect(env).toHaveProperty('torch');
-    expect(env).toHaveProperty('disk');
-  });
-});