@infersec/conduit 1.36.0 → 1.38.0

package/dist/cli.js

@@ -6,7 +6,7 @@ const __dirname = __pathDirname(__filename);
 
 import { parseArgs } from 'node:util';
 import 'node:crypto';
-import { a as asError, s as startInferenceAgent } from './start-CdILFvRO.js';
+import { a as asError, s as startInferenceAgent } from './start-BvzHFdA_.js';
 import 'argon2';
 import 'node:child_process';
 import 'node:stream';

package/dist/index.js

@@ -5,7 +5,7 @@ const __filename = __fileURLToPath(import.meta.url);
 const __dirname = __pathDirname(__filename);
 
 import 'node:crypto';
-import { s as startInferenceAgent, a as asError } from './start-CdILFvRO.js';
+import { s as startInferenceAgent, a as asError } from './start-BvzHFdA_.js';
 import 'argon2';
 import 'node:child_process';
 import 'node:stream';

package/dist/{start-CdILFvRO.js → start-BvzHFdA_.js}

@@ -119700,11 +119700,28 @@ createExeca(mapScriptAsync, {}, deepScriptOptions, setScriptSync);
 
 getIpcExport();
 
+const DRM_PATH = "/sys/class/drm";
+const GPU_PCI_CLASS_RE = /\[(03\d\d)\]/;
 const MACHINE_ID_PATHS = ["/etc/machine-id", "/var/lib/dbus/machine-id"];
+function stripQuotes(value) {
+    return value.replace(/^"|"$/g, "");
+}
+function extractHumanPart(value) {
+    return value.replace(/\s*\[[^\]]*\]\s*$/, "").trim();
+}
+async function readSysfsFile(filePath) {
+    try {
+        const contents = await readFile(filePath, "utf8");
+        return contents.trim();
+    }
+    catch {
+        return null;
+    }
+}
 async function readMachineIdentifier() {
-    for (const path of MACHINE_ID_PATHS) {
+    for (const targetPath of MACHINE_ID_PATHS) {
         try {
-            const contents = await readFile(path, "utf8");
+            const contents = await readFile(targetPath, "utf8");
             const trimmed = contents.trim();
             if (trimmed.length > 0) {
                 return trimmed;
@@ -119745,6 +119762,11 @@ function normalizeMegabytes(value) {
     }
     return Math.round(value * 1024 * 1024);
 }
+function normalizeBusAddress(bus) {
+    if (!bus)
+        return null;
+    return bus.toLowerCase().replace(/^0000:/, "");
+}
 function resolveCpuValue(value) {
     if (typeof value === "number" && Number.isFinite(value)) {
         return value;
@@ -119755,12 +119777,199 @@ function resolveCpuValue(value) {
     }
     return null;
 }
+async function detectGPUsViaLspci() {
+    try {
+        const { stdout } = await execa("lspci", ["-nn", "-mm", "-D"]);
+        const lines = stdout.split("\n");
+        const gpus = [];
+        for (const line of lines) {
+            const fields = line.split("\t");
+            if (fields.length < 4)
+                continue;
+            const classField = stripQuotes(fields[1] ?? "");
+            const classMatch = classField.match(GPU_PCI_CLASS_RE);
+            if (!classMatch)
+                continue;
+            const bus = stripQuotes(fields[0] ?? "");
+            const vendor = extractHumanPart(stripQuotes(fields[2] ?? ""));
+            const model = extractHumanPart(stripQuotes(fields[3] ?? ""));
+            if (bus && model) {
+                gpus.push({ bus, model, vendor });
+            }
+        }
+        return gpus;
+    }
+    catch {
+        return [];
+    }
+}
+async function resolveDrmCardBus(cardName) {
+    const deviceLink = path$1.join(DRM_PATH, cardName, "device");
+    try {
+        const { readlink } = await import('node:fs/promises');
+        const linkTarget = await readlink(deviceLink);
+        const basename = path$1.basename(linkTarget);
+        if (/^[0-9a-f]{4}:[0-9a-f]{2}:[0-9a-f]{2}\.\d$/i.test(basename)) {
+            return basename;
+        }
+    }
+    catch {
+        // Not a PCI device or readlink unavailable
+    }
+    return null;
+}
+async function enumerateDrmCards() {
+    try {
+        const entries = await readdir(DRM_PATH);
+        const buses = [];
+        for (const entry of entries) {
+            if (!entry.startsWith("card") || entry.includes("-"))
+                continue;
+            const bus = await resolveDrmCardBus(entry);
+            if (bus)
+                buses.push(bus);
+        }
+        return buses;
+    }
+    catch {
+        return [];
+    }
+}
+async function detectVRAMViaSysfs(pciBusSuffix) {
+    try {
+        const entries = await readdir(DRM_PATH);
+        for (const entry of entries) {
+            if (!entry.startsWith("card") || entry.includes("-"))
+                continue;
+            const cardBus = await resolveDrmCardBus(entry);
+            if (!cardBus)
+                continue;
+            const normalizedCard = normalizeBusAddress(cardBus);
+            const normalizedTarget = normalizeBusAddress(pciBusSuffix);
+            if (normalizedCard !== normalizedTarget)
+                continue;
+            const deviceDir = path$1.join(DRM_PATH, entry, "device");
+            const totalStr = await readSysfsFile(path$1.join(deviceDir, "mem_info_vram_total"));
+            const usedStr = await readSysfsFile(path$1.join(deviceDir, "mem_info_vram_used"));
+            const totalBytes = totalStr !== null ? parseInt(totalStr, 10) : null;
+            const usedBytes = usedStr !== null ? parseInt(usedStr, 10) : null;
+            const validTotal = totalBytes !== null && Number.isFinite(totalBytes) && totalBytes >= 0;
+            const validUsed = usedBytes !== null && Number.isFinite(usedBytes) && usedBytes >= 0;
+            if (validTotal) {
+                return {
+                    memoryTotalBytes: totalBytes,
+                    memoryUsedBytes: validUsed ? usedBytes : null
+                };
+            }
+        }
+    }
+    catch {
+        // sysfs not available
+    }
+    return { memoryTotalBytes: null, memoryUsedBytes: null };
+}
+async function detectVRAMViaRocmSmi() {
+    try {
+        const { stdout } = await execa("rocm-smi", [
+            "--showbus",
+            "--showmeminfo",
+            "vram",
+            "--json"
+        ]);
+        const parsed = JSON.parse(stdout);
+        const results = [];
+        const cards = Object.entries(parsed).filter(([key]) => key.startsWith("card"));
+        for (const [, data] of cards) {
+            const bus = data["PCI Bus"] ?? null;
+            const totalStr = data["VRAM Total Memory (B)"] ?? null;
+            const usedStr = data["VRAM Total Used Memory (B)"] ?? null;
+            const totalBytes = totalStr !== null ? parseInt(totalStr, 10) : null;
+            const usedBytes = usedStr !== null ? parseInt(usedStr, 10) : null;
+            const validTotal = totalBytes !== null && Number.isFinite(totalBytes) && totalBytes >= 0;
+            const validUsed = usedBytes !== null && Number.isFinite(usedBytes) && usedBytes >= 0;
+            if (bus) {
+                results.push({
+                    bus,
+                    memoryTotalBytes: validTotal ? totalBytes : null,
+                    memoryUsedBytes: validUsed ? usedBytes : null
+                });
+            }
+        }
+        return results;
+    }
+    catch {
+        return [];
+    }
+}
+function buildMergedGPUs(options) {
+    const { lspciGPUs, rocmVRAM, siGPUs, sysfsVRAMMap } = options;
+    const siByBus = new Map();
+    for (const gpu of siGPUs) {
+        const key = normalizeBusAddress(gpu.bus);
+        if (key)
+            siByBus.set(key, gpu);
+    }
+    const rocmByBus = new Map();
+    for (const entry of rocmVRAM) {
+        const key = normalizeBusAddress(entry.bus);
+        if (key)
+            rocmByBus.set(key, entry);
+    }
+    const seen = new Set();
+    const merged = [...siGPUs];
+    for (const lspciGPU of lspciGPUs) {
+        const key = normalizeBusAddress(lspciGPU.bus);
+        if (!key || seen.has(key))
+            continue;
+        seen.add(key);
+        const existing = siByBus.get(key);
+        if (existing) {
+            if (existing.memoryTotalBytes === null) {
+                const sysfs = sysfsVRAMMap.get(key);
+                const sysfsTotal = sysfs?.memoryTotalBytes ?? null;
+                const sysfsUsed = sysfs?.memoryUsedBytes ?? null;
+                const validSysfsTotal = sysfsTotal !== null && Number.isFinite(sysfsTotal);
+                const validSysfsUsed = sysfsUsed !== null && Number.isFinite(sysfsUsed);
+                if (validSysfsTotal) {
+                    existing.memoryTotalBytes = sysfsTotal;
+                    existing.memoryFreeBytes =
+                        validSysfsUsed && sysfsUsed !== null ? sysfsTotal - sysfsUsed : null;
+                }
+            }
+            continue;
+        }
+        const sysfs = sysfsVRAMMap.get(key);
+        let totalBytes = sysfs?.memoryTotalBytes ?? null;
+        let usedBytes = sysfs?.memoryUsedBytes ?? null;
+        if (totalBytes === null) {
+            const rocm = rocmByBus.get(key);
+            if (rocm) {
+                totalBytes = rocm.memoryTotalBytes;
+                usedBytes = rocm.memoryUsedBytes;
+            }
+        }
+        merged.push({
+            bus: lspciGPU.bus,
+            driverVersion: null,
+            memoryFreeBytes: totalBytes !== null && usedBytes !== null && Number.isFinite(usedBytes)
+                ? totalBytes - usedBytes
+                : null,
+            memoryTotalBytes: totalBytes,
+            model: lspciGPU.model,
+            temperatureCelsius: null,
+            vendor: lspciGPU.vendor
+        });
+    }
+    return merged;
+}
 async function collectMachineMetadata() {
-    const [cpuResult, memResult, osResult, graphicsResult] = await Promise.allSettled([
+    const [cpuResult, memResult, osResult, graphicsResult, lspciGPUs, rocmVRAM] = await Promise.allSettled([
         si.cpu(),
         si.mem(),
         si.osInfo(),
-        si.graphics()
+        si.graphics(),
+        detectGPUsViaLspci(),
+        detectVRAMViaRocmSmi()
     ]);
     const cpuInfo = cpuResult.status === "fulfilled" ? cpuResult.value : null;
     const memInfo = memResult.status === "fulfilled" ? memResult.value : null;
@@ -119768,7 +119977,9 @@ async function collectMachineMetadata() {
     const graphicsInfo = graphicsResult.status === "fulfilled"
         ? graphicsResult.value
         : { controllers: [] };
-    const gpus = (graphicsInfo.controllers ?? []).map((controller) => ({
+    const resolvedLspciGPUs = lspciGPUs.status === "fulfilled" ? lspciGPUs.value : [];
+    const resolvedRocmVRAM = rocmVRAM.status === "fulfilled" ? rocmVRAM.value : [];
+    const siGPUs = (graphicsInfo.controllers ?? []).map((controller) => ({
         bus: controller.bus ?? null,
         driverVersion: controller.driverVersion ?? null,
         memoryFreeBytes: normalizeMegabytes(controller.memoryFree ?? null),
@@ -119777,6 +119988,32 @@ async function collectMachineMetadata() {
         temperatureCelsius: controller.temperatureGpu ?? null,
         vendor: controller.vendor ?? null
     }));
+    const busSources = new Set();
+    for (const lspciGPU of resolvedLspciGPUs) {
+        busSources.add(lspciGPU.bus);
+    }
+    for (const siGPU of siGPUs) {
+        if (siGPU.bus)
+            busSources.add(siGPU.bus);
+    }
+    const drmBuses = await enumerateDrmCards();
+    for (const bus of drmBuses) {
+        busSources.add(bus);
+    }
+    const sysfsVRAMMap = new Map();
+    for (const bus of busSources) {
+        const busSuffix = bus.replace(/^0000:/, "");
+        const vram = await detectVRAMViaSysfs(busSuffix);
+        const key = normalizeBusAddress(bus);
+        if (key)
+            sysfsVRAMMap.set(key, vram);
+    }
+    const gpus = buildMergedGPUs({
+        lspciGPUs: resolvedLspciGPUs,
+        rocmVRAM: resolvedRocmVRAM,
+        siGPUs,
+        sysfsVRAMMap
+    });
     const machineMetadata = {
         cpu: {
             baseClockGHz: resolveCpuValue(cpuInfo?.speed ?? null),

package/dist/utils/machineInfo.d.ts

@@ -1,2 +1,2 @@
-import { InferenceAgentMachineMetadata } from "@infersec/definitions";
+import type { InferenceAgentMachineMetadata } from "@infersec/definitions";
 export declare function collectMachineMetadata(): Promise<InferenceAgentMachineMetadata>;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@infersec/conduit",
   "description": "End user conduit agent for connecting local LLMs to the cloud.",
-  "version": "1.36.0",
+  "version": "1.38.0",
   "bin": {
     "infersec-conduit": "./dist/cli.js"
   },