sublera-cli 0.0.0-stage → 1.3.0

package/dist/exitCodes.js

@@ -0,0 +1,20 @@
+/**
+ * Process exit codes. These are part of the public contract: service managers,
+ * scripts, and fleet tooling may branch on them, so a code never changes meaning.
+ */
+export const EXIT = {
+    /** Success, or a booking that ended normally. */
+    OK: 0,
+    /** A runtime failure: server unreachable, host key rejected, a failed check, a crash loop. */
+    ERROR: 1,
+    /** Bad command line or bad settings (unknown option, invalid agent.json, invalid proxy). */
+    USAGE: 2,
+    /** Stopped with Ctrl+C (SIGINT). Saved booking state is cleared. */
+    INTERRUPTED: 130,
+    /** Stopped by the system or a service manager (SIGTERM). Saved booking state is kept for the next start. */
+    TERMINATED: 143,
+};
+/** Configuration failures should not be retried forever by service managers. */
+export class UsageError extends Error {
+}
+//# sourceMappingURL=exitCodes.js.map

package/dist/hardware/gpuMonitor.d.ts

@@ -0,0 +1,32 @@
+import type { FitResult, GpuMonitorOptions, GpuProcess, GpuSnapshot, GpuStats, GpuVendor } from './types.js';
+export declare function parseNvidiaCsv(text: string): GpuStats[];
+export declare function parseNvidiaProcesses(text: string): GpuProcess[];
+export declare function parseRocmJson(raw: unknown): GpuStats[];
+export declare function parseSystemProfiler(raw: unknown, totalSystemMemoryMb?: number): GpuStats[];
+export declare function parseWmicJson(raw: unknown): GpuStats[];
+export declare function choosePrimary(gpus: GpuStats[]): GpuStats | null;
+export declare function checkFit(needsMb: number, gpu: GpuStats | null, safetyRatio?: number): FitResult;
+export declare class GpuMonitor {
+    private readonly platform;
+    private readonly exec;
+    private readonly env;
+    private readonly cacheMs;
+    private cached;
+    constructor(options?: GpuMonitorOptions);
+    scan(force?: boolean): Promise<GpuSnapshot>;
+    private detect;
+    private snapshot;
+    private detectNvidia;
+    private detectRocm;
+    private detectApple;
+    private detectWindows;
+    private detectLspci;
+}
+export declare function gpuSummary(monitor: GpuMonitor, force?: boolean): Promise<GpuSnapshot>;
+export type GpuOverride = {
+    name: string | null;
+    vramMb: number | null;
+};
+export declare function vendorFromName(name: string): GpuVendor;
+/** `--gpu` / `--vram` win over detection, for cards that report wrong values (for example 4 GB on Windows). */
+export declare function applyGpuOverride(snapshot: GpuSnapshot, override: GpuOverride | null | undefined): GpuSnapshot;

package/dist/hardware/gpuMonitor.js

@@ -0,0 +1,378 @@
+import { execFile as realExecFile } from '../util/exec.js';
+function num(value) {
+    if (value == null)
+        return null;
+    const cleaned = String(value).replace(/[^\d.+-]/g, '').trim();
+    if (!cleaned || cleaned === '-' || cleaned === '+')
+        return null;
+    const n = Number(cleaned);
+    return Number.isFinite(n) ? n : null;
+}
+function clampMb(value) {
+    if (value == null || !Number.isFinite(value) || value < 0)
+        return 0;
+    return Math.round(value);
+}
+export function parseNvidiaCsv(text) {
+    const gpus = [];
+    const lines = text.split(/\r?\n/).map((l) => l.trim()).filter(Boolean);
+    for (const [index, line] of lines.entries()) {
+        const cols = line.split(',').map((c) => c.trim());
+        if (cols.length < 3)
+            continue;
+        const name = cols[0] || 'NVIDIA GPU';
+        const total = clampMb(num(cols[1]));
+        const freeRaw = num(cols[2]);
+        const free = freeRaw == null ? total : clampMb(freeRaw);
+        const used = Math.max(0, total - free);
+        const utilization = num(cols[3]);
+        const temp = num(cols[4]);
+        const power = num(cols[5]);
+        const limit = num(cols[6]);
+        gpus.push({
+            index,
+            name,
+            vendor: 'nvidia',
+            totalVramMb: total,
+            freeVramMb: free,
+            usedVramMb: used,
+            utilizationPct: utilization,
+            temperatureC: temp,
+            powerW: power,
+            powerLimitW: limit,
+            processes: [],
+        });
+    }
+    return gpus;
+}
+export function parseNvidiaProcesses(text) {
+    const out = [];
+    for (const line of text.split(/\r?\n/).map((l) => l.trim()).filter(Boolean)) {
+        const cols = line.split(',').map((c) => c.trim());
+        if (cols.length < 3)
+            continue;
+        const pid = Number(cols[0]);
+        if (!Number.isFinite(pid))
+            continue;
+        out.push({ pid, name: cols[1] || 'process', usedMb: clampMb(num(cols[2])) });
+    }
+    return out;
+}
+export function parseRocmJson(raw) {
+    if (!raw || typeof raw !== 'object')
+        return [];
+    const data = raw;
+    const gpus = [];
+    let index = 0;
+    for (const [card, values] of Object.entries(data)) {
+        if (!/^card\d+$/i.test(card) || !values || typeof values !== 'object')
+            continue;
+        const entries = Object.entries(values).reduce((acc, [key, value]) => {
+            acc[key.toLowerCase()] = String(value);
+            return acc;
+        }, {});
+        const name = entries['card series'] || entries['card model'] || entries['product name'] || entries['card sku'] || 'AMD GPU';
+        const total = clampMb(num(entries['vram total memory (b)']) ? Number(entries['vram total memory (b)']) / 1024 / 1024 : num(entries['vram total size']));
+        const usedBytes = entries['vram total used memory (b)'] ?? entries['vram used memory (b)'];
+        const used = clampMb(num(usedBytes) ? Number(usedBytes) / 1024 / 1024 : num(entries['vram used size']));
+        gpus.push({
+            index,
+            name,
+            vendor: 'amd',
+            totalVramMb: total,
+            freeVramMb: Math.max(0, total - used),
+            usedVramMb: used,
+            utilizationPct: num(entries['gpu use (%)'] || entries['gpu utilization']),
+            temperatureC: num(entries['temperature (sensor edge) (c)'] || entries['temperature (sensor junction) (c)'] || entries['temperature']),
+            powerW: num(entries['average power (w)'] || entries['power (w)']),
+            powerLimitW: num(entries['max power (w)']),
+            processes: [],
+        });
+        index++;
+    }
+    return gpus;
+}
+export function parseSystemProfiler(raw, totalSystemMemoryMb = 0) {
+    if (!raw || typeof raw !== 'object')
+        return [];
+    const displays = raw.SPDisplaysDataType;
+    if (!Array.isArray(displays) || !displays.length)
+        return [];
+    return displays.map((display, index) => {
+        const name = display.sppci_model || display._name || 'Apple GPU';
+        const vramText = display.spdisplays_vram || display.spdisplays_vram_shared || '';
+        const match = vramText.match(/(\d+(?:\.\d+)?)\s*(GB|MB)/i);
+        let vram = 0;
+        if (match)
+            vram = clampMb(Number(match[1]) * (/gb/i.test(match[2] || '') ? 1024 : 1));
+        else if (totalSystemMemoryMb > 0)
+            vram = totalSystemMemoryMb;
+        return {
+            index,
+            name,
+            vendor: 'apple',
+            totalVramMb: vram,
+            // macOS does not expose a reliable free-VRAM number for unified memory.
+            freeVramMb: vram,
+            usedVramMb: 0,
+            utilizationPct: null,
+            temperatureC: null,
+            powerW: null,
+            powerLimitW: null,
+            processes: [],
+        };
+    });
+}
+export function parseWmicJson(raw) {
+    let rows = [];
+    if (Array.isArray(raw))
+        rows = raw;
+    else if (raw && typeof raw === 'object')
+        rows = [raw];
+    const out = [];
+    for (const row of rows) {
+        const name = row.Name || 'GPU';
+        if (/microsoft basic|remote display|virtual/i.test(name))
+            continue;
+        let ram = Number(row.AdapterRAM || 0);
+        if (!Number.isFinite(ram) || ram < 0)
+            ram = Math.abs(ram);
+        const total = clampMb(ram / 1024 / 1024);
+        const vendor = /nvidia/i.test(name) ? 'nvidia' : /amd|radeon/i.test(name) ? 'amd' : /intel/i.test(name) ? 'intel' : 'unknown';
+        out.push({
+            index: out.length,
+            name,
+            vendor,
+            totalVramMb: total,
+            freeVramMb: total,
+            usedVramMb: 0,
+            utilizationPct: null,
+            temperatureC: null,
+            powerW: null,
+            powerLimitW: null,
+            processes: [],
+        });
+    }
+    return out;
+}
+export function choosePrimary(gpus) {
+    if (!gpus.length)
+        return null;
+    const discrete = gpus.filter((g) => g.vendor === 'nvidia' || g.vendor === 'amd' || g.vendor === 'apple');
+    const pool = discrete.length ? discrete : gpus;
+    return [...pool].sort((a, b) => b.totalVramMb - a.totalVramMb || (b.utilizationPct || 0) - (a.utilizationPct || 0))[0] || null;
+}
+export function checkFit(needsMb, gpu, safetyRatio = 0.02) {
+    if (!gpu) {
+        return { ok: false, reason: 'No GPU detected', freeMb: 0, needsMb, headroomMb: -needsMb };
+    }
+    // Some cards are found without a memory size (for example through lspci only). Unknown is not "0 GB free";
+    // the load itself shows whether the model fits, and --vram can set the size.
+    if (gpu.totalVramMb <= 0)
+        return { ok: true, reason: 'VRAM size unknown', freeMb: 0, needsMb, headroomMb: 0 };
+    const budget = gpu.freeVramMb;
+    const overhead = Math.max(256, Math.round(needsMb * safetyRatio));
+    const required = needsMb + overhead;
+    return {
+        ok: required <= budget,
+        reason: required <= budget
+            ? undefined
+            : `Needs about ${(required / 1024).toFixed(1)}GB free, this GPU has ${(budget / 1024).toFixed(1)}GB free`,
+        freeMb: budget,
+        needsMb: required,
+        headroomMb: budget - required,
+    };
+}
+export class GpuMonitor {
+    platform;
+    exec;
+    env;
+    cacheMs;
+    cached = null;
+    constructor(options = {}) {
+        this.platform = options.platform ?? process.platform;
+        this.exec = options.exec ?? realExecFile;
+        this.env = options.env ?? process.env;
+        this.cacheMs = options.cacheMs ?? 1_000;
+    }
+    async scan(force = false) {
+        if (!force && this.cached && Date.now() - this.cached.checkedAt < this.cacheMs)
+            return this.cached;
+        const snapshot = await this.detect();
+        this.cached = snapshot;
+        return snapshot;
+    }
+    async detect() {
+        const warnings = [];
+        const nvidia = await this.detectNvidia(warnings);
+        if (nvidia.length)
+            return this.snapshot(nvidia, 'nvidia-smi', warnings);
+        const rocm = await this.detectRocm(warnings);
+        if (rocm.length)
+            return this.snapshot(rocm, 'rocm-smi', warnings);
+        if (this.platform === 'darwin') {
+            const apple = await this.detectApple(warnings);
+            if (apple.length)
+                return this.snapshot(apple, 'system_profiler', warnings);
+        }
+        if (this.platform === 'win32') {
+            const wmic = await this.detectWindows(warnings);
+            if (wmic.length)
+                return this.snapshot(wmic, 'win32_VideoController', warnings);
+        }
+        const lspci = await this.detectLspci(warnings);
+        if (lspci.length)
+            return this.snapshot(lspci, 'lspci', warnings);
+        warnings.push('No supported GPU detected. Use --gpu and --vram to run in test mode.');
+        return this.snapshot([], 'none', warnings);
+    }
+    snapshot(gpus, source, warnings) {
+        return {
+            gpus,
+            primary: choosePrimary(gpus),
+            source,
+            platform: this.platform,
+            checkedAt: Date.now(),
+            warnings,
+        };
+    }
+    async detectNvidia(warnings) {
+        const fields = 'name,memory.total,memory.free,utilization.gpu,temperature.gpu,power.draw,power.limit';
+        const result = await this.exec('nvidia-smi', [
+            `--query-gpu=${fields}`,
+            '--format=csv,noheader,nounits',
+        ], { timeoutMs: 10_000 });
+        if (result.code !== 0 || !result.stdout.trim()) {
+            if (result.error && !/ENOENT|not found/i.test(result.error))
+                warnings.push(`nvidia-smi: ${result.error}`);
+            return [];
+        }
+        const gpus = parseNvidiaCsv(result.stdout);
+        if (!gpus.length)
+            return [];
+        const processes = await this.exec('nvidia-smi', [
+            '--query-compute-apps=pid,process_name,used_memory',
+            '--format=csv,noheader,nounits',
+        ], { timeoutMs: 10_000 });
+        if (processes.code === 0 && processes.stdout.trim()) {
+            const all = parseNvidiaProcesses(processes.stdout);
+            const ownPid = process.pid;
+            for (const gpu of gpus) {
+                gpu.processes = all.filter((p) => p.pid !== ownPid && p.pid !== 0 && p.usedMb >= 128);
+            }
+        }
+        return gpus;
+    }
+    async detectRocm(warnings) {
+        const result = await this.exec('rocm-smi', [
+            '--showproductname', '--showmeminfo', 'vram', '--showuse', '--showtemp', '--showpower', '--json',
+        ], { timeoutMs: 10_000 });
+        if (result.code !== 0 || !result.stdout.trim()) {
+            if (result.error && !/ENOENT|not found/i.test(result.error))
+                warnings.push(`rocm-smi: ${result.error}`);
+            return [];
+        }
+        try {
+            return parseRocmJson(JSON.parse(result.stdout));
+        }
+        catch {
+            warnings.push('Could not parse rocm-smi JSON');
+            return [];
+        }
+    }
+    async detectApple(warnings) {
+        const display = await this.exec('system_profiler', ['SPDisplaysDataType', '-json'], { timeoutMs: 15_000 });
+        if (display.code !== 0 || !display.stdout.trim())
+            return [];
+        let totalMb = 0;
+        const mem = await this.exec('sysctl', ['-n', 'hw.memsize'], { timeoutMs: 5_000 });
+        if (mem.code === 0)
+            totalMb = Math.round(Number(mem.stdout.trim()) / 1024 / 1024);
+        try {
+            const gpus = parseSystemProfiler(JSON.parse(display.stdout), totalMb);
+            if (gpus.length && !gpus.some((g) => g.totalVramMb > 0))
+                warnings.push('Apple unified memory size was not reported');
+            return gpus;
+        }
+        catch {
+            warnings.push('Could not parse system_profiler output');
+            return [];
+        }
+    }
+    async detectWindows(warnings) {
+        const script = "Get-CimInstance Win32_VideoController | Select-Object Name,AdapterRAM | ConvertTo-Json -Compress";
+        const result = await this.exec('powershell', ['-NoProfile', '-NonInteractive', '-Command', script], { timeoutMs: 15_000 });
+        if (result.code !== 0 || !result.stdout.trim())
+            return [];
+        try {
+            const gpus = parseWmicJson(JSON.parse(result.stdout));
+            if (gpus.length && gpus.every((g) => g.totalVramMb < 512)) {
+                warnings.push('Windows reported less than 512MB VRAM; use --vram to override.');
+            }
+            return gpus;
+        }
+        catch {
+            warnings.push('Could not parse Windows video controller output');
+            return [];
+        }
+    }
+    async detectLspci(warnings) {
+        if (this.platform !== 'linux')
+            return [];
+        const result = await this.exec('lspci', [], { timeoutMs: 8_000 });
+        if (result.code !== 0)
+            return [];
+        const lines = result.stdout.split(/\r?\n/).filter((l) => /VGA|3D controller|Display controller/i.test(l));
+        return lines.map((line, index) => {
+            const name = line.replace(/^[0-9a-f:.]+\s+[^:]+:\s*/i, '').trim();
+            const vendor = /nvidia/i.test(name) ? 'nvidia' : /amd|ati|radeon/i.test(name) ? 'amd' : /intel/i.test(name) ? 'intel' : 'unknown';
+            return {
+                index,
+                name,
+                vendor,
+                totalVramMb: 0,
+                freeVramMb: 0,
+                usedVramMb: 0,
+                utilizationPct: null,
+                temperatureC: null,
+                powerW: null,
+                powerLimitW: null,
+                processes: [],
+            };
+        }).filter((g) => g.name.length > 0);
+    }
+}
+export async function gpuSummary(monitor, force = false) {
+    const snapshot = await monitor.scan(force);
+    if (!snapshot.gpus.length)
+        void 0;
+    return snapshot;
+}
+export function vendorFromName(name) {
+    if (/nvidia|geforce|rtx|gtx|quadro|tesla/i.test(name))
+        return 'nvidia';
+    if (/amd|radeon/i.test(name))
+        return 'amd';
+    if (/apple|\bm[1-9]\b/i.test(name))
+        return 'apple';
+    if (/intel|\barc\b/i.test(name))
+        return 'intel';
+    return 'unknown';
+}
+/** `--gpu` / `--vram` win over detection, for cards that report wrong values (for example 4 GB on Windows). */
+export function applyGpuOverride(snapshot, override) {
+    if (!override || (!override.name && !override.vramMb))
+        return snapshot;
+    const base = snapshot.primary;
+    const name = override.name || base?.name || 'Unknown GPU';
+    const totalVramMb = override.vramMb ?? base?.totalVramMb ?? 0;
+    const primary = base
+        ? { ...base, name, totalVramMb, freeVramMb: override.vramMb != null ? Math.max(0, override.vramMb - base.usedVramMb) : base.freeVramMb }
+        : {
+            index: 0, name, vendor: vendorFromName(name), totalVramMb, freeVramMb: totalVramMb, usedVramMb: 0,
+            utilizationPct: 0, temperatureC: null, powerW: null, powerLimitW: null, processes: [],
+        };
+    const gpus = base ? snapshot.gpus.map((gpu) => (gpu === base ? primary : gpu)) : [primary, ...snapshot.gpus];
+    return { ...snapshot, gpus, primary, source: base ? snapshot.source : 'override' };
+}
+//# sourceMappingURL=gpuMonitor.js.map

package/dist/hardware/sleepGuard.d.ts

@@ -0,0 +1,42 @@
+import { spawn as realSpawn } from 'node:child_process';
+import { killTree, which } from '../util/exec.js';
+import type { Logger } from '../logger.js';
+type SpawnFn = typeof realSpawn;
+export type SleepGuardOptions = {
+    platform?: NodeJS.Platform;
+    spawnFn?: SpawnFn;
+    logger?: Logger;
+    whichFn?: typeof which;
+    killFn?: typeof killTree;
+};
+export type SleepGuardState = {
+    active: boolean;
+    supported: boolean;
+    platform: NodeJS.Platform;
+    mechanism: string;
+    since: number | null;
+    lastError: string | null;
+};
+export declare function windowsSleepScript(): string;
+export declare class SleepGuard {
+    private readonly platform;
+    private readonly spawnFn;
+    private readonly logger?;
+    private readonly whichFn;
+    private readonly killFn;
+    private child;
+    private state;
+    private stopping;
+    private exitHandler;
+    constructor(options?: SleepGuardOptions);
+    private mechanismName;
+    status(): SleepGuardState;
+    acquire(reason: string): Promise<boolean>;
+    private startWindows;
+    private startDarwin;
+    private startLinux;
+    private attach;
+    stop(): Promise<void>;
+}
+export declare function sleepGuardAvailable(platform?: NodeJS.Platform, whichFn?: typeof which): Promise<boolean>;
+export {};

package/dist/hardware/sleepGuard.js

@@ -0,0 +1,149 @@
+import { spawn as realSpawn } from 'node:child_process';
+import { killTree, which } from '../util/exec.js';
+export function windowsSleepScript() {
+    return [
+        "$src = @'",
+        'using System;',
+        'using System.Runtime.InteropServices;',
+        'public static class SubletSleepGuard {',
+        '  [DllImport("kernel32.dll", SetLastError = true)]',
+        '  public static extern uint SetThreadExecutionState(uint esFlags);',
+        '}',
+        "'@",
+        'Add-Type -TypeDefinition $src',
+        'while ($true) {',
+        '  [SubletSleepGuard]::SetThreadExecutionState([uint32]2147483651) | Out-Null',
+        '  Start-Sleep -Seconds 20',
+        '}',
+    ].join('\n');
+}
+export class SleepGuard {
+    platform;
+    spawnFn;
+    logger;
+    whichFn;
+    killFn;
+    child = null;
+    state;
+    stopping = false;
+    exitHandler = null;
+    constructor(options = {}) {
+        this.platform = options.platform ?? process.platform;
+        this.spawnFn = options.spawnFn ?? realSpawn;
+        this.logger = options.logger;
+        this.whichFn = options.whichFn ?? which;
+        this.killFn = options.killFn ?? killTree;
+        this.state = {
+            active: false,
+            supported: this.platform === 'win32' || this.platform === 'darwin' || this.platform === 'linux',
+            platform: this.platform,
+            mechanism: this.mechanismName(),
+            since: null,
+            lastError: null,
+        };
+    }
+    mechanismName() {
+        if (this.platform === 'win32')
+            return 'SetThreadExecutionState';
+        if (this.platform === 'darwin')
+            return 'caffeinate';
+        if (this.platform === 'linux')
+            return 'systemd-inhibit';
+        return 'unsupported';
+    }
+    status() {
+        return { ...this.state };
+    }
+    async acquire(reason) {
+        if (this.state.active)
+            return true;
+        try {
+            if (this.platform === 'win32')
+                return this.startWindows(reason);
+            if (this.platform === 'darwin')
+                return this.startDarwin(reason);
+            if (this.platform === 'linux')
+                return this.startLinux(reason);
+            this.state.lastError = `Sleep blocking is not implemented on ${this.platform}`;
+            return false;
+        }
+        catch (error) {
+            this.state.lastError = error instanceof Error ? error.message : String(error);
+            this.logger?.warn('Could not block sleep', { error: this.state.lastError });
+            return false;
+        }
+    }
+    startWindows(reason) {
+        const child = this.spawnFn('powershell', [
+            '-NoProfile',
+            '-NonInteractive',
+            '-WindowStyle', 'Hidden',
+            '-Command', windowsSleepScript(),
+        ], { windowsHide: true, stdio: 'ignore' });
+        return this.attach(child, `Windows wake-lock (${reason})`);
+    }
+    startDarwin(reason) {
+        const child = this.spawnFn('caffeinate', ['-dimsu', '-w', String(process.pid)], { stdio: 'ignore' });
+        return this.attach(child, `caffeinate (${reason})`);
+    }
+    startLinux(reason) {
+        const child = this.spawnFn('systemd-inhibit', [
+            '--what=sleep:idle',
+            '--who=sublera-cli',
+            `--why=${reason.slice(0, 80)}`,
+            'tail', `--pid=${process.pid}`, '-f', '/dev/null',
+        ], { stdio: 'ignore' });
+        return this.attach(child, `systemd-inhibit (${reason})`);
+    }
+    attach(child, description) {
+        this.child = child;
+        this.stopping = false;
+        this.state = {
+            active: true,
+            supported: true,
+            platform: this.platform,
+            mechanism: this.mechanismName(),
+            since: Date.now(),
+            lastError: null,
+        };
+        child.once('error', (error) => {
+            this.state.active = false;
+            this.state.lastError = error.message;
+            this.logger?.warn(`Sleep guard failed: ${error.message}`);
+        });
+        child.once('exit', (code) => {
+            this.state.active = false;
+            this.state.since = null;
+            if (!this.stopping) {
+                this.logger?.warn(`Sleep guard exited unexpectedly (${description}, code ${code ?? '?'})`);
+            }
+        });
+        this.exitHandler = () => { void this.stop(); };
+        process.once('exit', this.exitHandler);
+        this.logger?.info(`Sleep blocked: ${description}`);
+        return true;
+    }
+    async stop() {
+        this.stopping = true;
+        if (this.exitHandler) {
+            process.removeListener('exit', this.exitHandler);
+            this.exitHandler = null;
+        }
+        const child = this.child;
+        this.child = null;
+        this.state.active = false;
+        this.state.since = null;
+        if (child)
+            await this.killFn(child);
+    }
+}
+export async function sleepGuardAvailable(platform = process.platform, whichFn = which) {
+    if (platform === 'win32')
+        return true;
+    if (platform === 'darwin')
+        return (await whichFn('caffeinate')) != null;
+    if (platform === 'linux')
+        return (await whichFn('systemd-inhibit')) != null;
+    return false;
+}
+//# sourceMappingURL=sleepGuard.js.map

package/dist/hardware/types.d.ts

@@ -0,0 +1,40 @@
+export type GpuVendor = 'nvidia' | 'amd' | 'apple' | 'intel' | 'unknown';
+export type GpuProcess = {
+    pid: number;
+    name: string;
+    usedMb: number;
+};
+export type GpuStats = {
+    index: number;
+    name: string;
+    vendor: GpuVendor;
+    totalVramMb: number;
+    freeVramMb: number;
+    usedVramMb: number;
+    utilizationPct: number | null;
+    temperatureC: number | null;
+    powerW: number | null;
+    powerLimitW: number | null;
+    processes: GpuProcess[];
+};
+export type GpuSnapshot = {
+    gpus: GpuStats[];
+    primary: GpuStats | null;
+    source: string;
+    platform: NodeJS.Platform;
+    checkedAt: number;
+    warnings: string[];
+};
+export type FitResult = {
+    ok: boolean;
+    reason?: string;
+    freeMb: number;
+    needsMb: number;
+    headroomMb: number;
+};
+export type GpuMonitorOptions = {
+    platform?: NodeJS.Platform;
+    exec?: typeof import('../util/exec.js').execFile;
+    env?: NodeJS.ProcessEnv;
+    cacheMs?: number;
+};

package/dist/hardware/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/health.d.ts

@@ -0,0 +1,17 @@
+export type AgentHealth = {
+    schemaVersion: 1;
+    agentVersion: string;
+    pid: number;
+    updatedAt: number;
+    live: boolean;
+    ready: boolean;
+    draining: boolean;
+    simulation: boolean;
+    tunnel: string;
+    engine: string;
+    activeJobs: number;
+    loading: boolean;
+};
+export declare function healthPath(env?: NodeJS.ProcessEnv): string;
+/** Local readiness only: not server attestation, billing approval, or a GPU benchmark. */
+export declare function readHealth(env?: NodeJS.ProcessEnv): Promise<AgentHealth>;