@synapseia-network/node 0.8.5

package/dist/chunk-NMJVODKH.js

@@ -0,0 +1,453 @@
+import { fileURLToPath as __synFup } from "url";import { dirname as __synDn } from "path";const __filename = __synFup(import.meta.url);const __dirname = __synDn(__filename);
+import {
+  init_logger,
+  logger_default
+} from "./chunk-V2L5SXTL.js";
+import {
+  __name
+} from "./chunk-D7ADMHK2.js";
+
+// src/modules/hardware/hardware.ts
+init_logger();
+import * as os from "os";
+import { execSync, spawnSync } from "child_process";
+import { URL } from "url";
+import { Injectable } from "@nestjs/common";
+function _ts_decorate(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate, "_ts_decorate");
+var hardwareLoggedOnce = false;
+var HardwareHelper = class {
+  static {
+    __name(this, "HardwareHelper");
+  }
+  /**
+  * Detect hardware capabilities
+  */
+  /** @internal exported for testing */
+  detectAppleSilicon(hardware, model) {
+    if (model.includes("M3 Ultra")) hardware.hardwareClass = 5;
+    else if (model.includes("M3 Max") || model.includes("M3 Pro")) hardware.hardwareClass = 4;
+    else if (model.includes("M2 Ultra")) hardware.hardwareClass = 3;
+    else if (model.includes("M2 Max")) hardware.hardwareClass = 3;
+    else if (model.includes("M2 Pro") || model.includes("M1 Ultra")) hardware.hardwareClass = 2;
+    else if (model.includes("M1 Max")) hardware.hardwareClass = 2;
+    else if (model.includes("M3") || model.includes("M2") || model.includes("M1")) hardware.hardwareClass = 1;
+    if (model.includes("Ultra")) hardware.gpuVramGb = hardware.hardwareClass === 5 ? 192 : 128;
+    else if (model.includes("Max")) hardware.gpuVramGb = 96;
+    else if (model.includes("Pro")) hardware.gpuVramGb = hardware.hardwareClass >= 3 ? 48 : 18;
+    else hardware.gpuVramGb = hardware.hardwareClass === 1 ? 10 : 7;
+  }
+  /** @internal exported for testing */
+  detectNvidiaGPU(hardware, smiOutput) {
+    if (!smiOutput) {
+      smiOutput = execSync("nvidia-smi --query-gpu=memory.free --format=csv,noheader,nounits", {
+        encoding: "utf-8"
+      });
+    }
+    if (smiOutput.includes("GiB")) {
+      const match = smiOutput.match(/(\d+)\s*GiB/);
+      if (match) hardware.gpuVramGb = parseInt(match[1]);
+    } else if (smiOutput.includes("MiB")) {
+      const match = smiOutput.match(/(\d+)\s*MiB/);
+      if (match) hardware.gpuVramGb = Math.round(parseInt(match[1]) / 1024);
+    }
+    if (hardware.gpuVramGb >= 80) hardware.hardwareClass = 5;
+    else if (hardware.gpuVramGb >= 64) hardware.hardwareClass = 5;
+    else if (hardware.hardwareClass < 5 && hardware.gpuVramGb >= 24) hardware.hardwareClass = 4;
+    else if (hardware.hardwareClass < 4 && hardware.gpuVramGb >= 14) hardware.hardwareClass = 3;
+    else if (hardware.hardwareClass < 3 && hardware.gpuVramGb >= 10) hardware.hardwareClass = 2;
+    else if (hardware.hardwareClass < 2 && hardware.gpuVramGb >= 6) hardware.hardwareClass = 1;
+  }
+  detectHardware(cpuOnly = false, archOverride) {
+    const hardware = {
+      cpuCores: os.cpus().length || 2,
+      ramGb: Math.round(os.totalmem() / 1024 ** 3),
+      gpuVramGb: 0,
+      hardwareClass: 0,
+      hasOllama: false
+    };
+    if (!cpuOnly) {
+      try {
+        const arch2 = archOverride || os.arch();
+        if (arch2 === "arm64") {
+          const model = execSync("sysctl -n machdep.cpu.brand_string").toString().trim();
+          this.detectAppleSilicon(hardware, model);
+          hardware.gpuModel = model;
+        } else if (arch2 === "x64" || arch2 === "x86") {
+          this.detectNvidiaGPU(hardware);
+          try {
+            const name = execSync("nvidia-smi --query-gpu=name --format=csv,noheader", {
+              encoding: "utf-8",
+              stdio: [
+                "ignore",
+                "pipe",
+                "ignore"
+              ]
+            }).split("\n")[0]?.trim();
+            if (name) hardware.gpuModel = name;
+          } catch {
+          }
+        }
+      } catch {
+      }
+      const ollamaUrl = process.env.OLLAMA_URL?.trim() || "http://localhost:11434";
+      let probeUrl = null;
+      try {
+        const parsed = new URL(ollamaUrl);
+        probeUrl = `${parsed.origin}/api/tags`;
+      } catch {
+        probeUrl = null;
+      }
+      if (probeUrl !== null) {
+        const result = spawnSync("curl", [
+          "-s",
+          "--max-time",
+          "2",
+          probeUrl
+        ], {
+          stdio: "pipe",
+          timeout: 2e3
+        });
+        hardware.hasOllama = result.status === 0 && !result.error;
+      } else {
+        hardware.hasOllama = false;
+      }
+      hardware.hasCloudLlm = !!(process.env.LLM_CLOUD_MODEL?.trim() || process.env.LLM_PROVIDER?.trim().toLowerCase() === "cloud");
+      if (!hardwareLoggedOnce) {
+        logger_default.info(`[hardware] hasOllama=${hardware.hasOllama} (url=${ollamaUrl}) hasCloudLlm=${hardware.hasCloudLlm} gpuVramGb=${hardware.gpuVramGb} hardwareClass=${hardware.hardwareClass}`);
+        hardwareLoggedOnce = true;
+      }
+    }
+    return hardware;
+  }
+  /**
+  * Get tier name
+  */
+  getTierName(tier) {
+    const names = [
+      "CPU-Only",
+      "Tier 1",
+      "Tier 2",
+      "Tier 3",
+      "Tier 4",
+      "Tier 5"
+    ];
+    return names[tier] || "Unknown";
+  }
+  /** @internal Build OS string — exported for testing */
+  buildOsString(platform2, release2, arch2, osType) {
+    if (platform2 === "darwin") return `macOS ${release2} (${arch2})`;
+    if (platform2 === "linux") return `Linux ${release2} (${arch2})`;
+    if (platform2 === "win32") return `Windows ${release2} (${arch2})`;
+    return `${osType} ${release2} (${arch2})`;
+  }
+  /** @internal Estimate Apple Silicon VRAM — exported for testing */
+  estimateAppleSiliconVram(model) {
+    if (model.includes("M3 Ultra")) return 192;
+    if (model.includes("M3 Max")) return 128;
+    if (model.includes("M2 Ultra")) return 128;
+    if (model.includes("M2 Max")) return 96;
+    if (model.includes("M3 Pro")) return 48;
+    if (model.includes("M2 Pro")) return 18;
+    if (model.includes("M1 Ultra")) return 128;
+    if (model.includes("M1 Max")) return 96;
+    if (model.includes("M3") || model.includes("M2")) return 10;
+    if (model.includes("M1")) return 7;
+    return 0;
+  }
+  /** @internal Parse nvidia-smi CSV output — exported for testing */
+  parseNvidiaSmiOutput(smiOutput) {
+    const lines = smiOutput.trim().split("\n");
+    const parts = lines[0]?.split(",")?.map((s) => s.trim()) || [];
+    const name = parts[0] || "NVIDIA GPU";
+    const vramStr = parts[1] || "";
+    const match = vramStr.match(/(\d+)\s*(GiB|MiB)/);
+    if (!match) return {
+      name,
+      vramGb: 0
+    };
+    const value = parseInt(match[1]);
+    const unit = match[2];
+    const vramGb = unit === "GiB" ? value : Math.round(value / 1024);
+    return {
+      name,
+      vramGb
+    };
+  }
+  /**
+  * Get system information
+  */
+  getSystemInfo(archOverride) {
+    const osPlatform = os.platform();
+    const osRelease = os.release();
+    const arch2 = archOverride || os.arch();
+    const osString = this.buildOsString(osPlatform, osRelease, arch2, os.type());
+    const cpuModel = os.cpus()[0]?.model || "Unknown CPU";
+    const cpuCores = os.cpus().length || 0;
+    const memoryTotal = os.totalmem();
+    let gpuType = null;
+    let gpuVram = 0;
+    try {
+      if (arch2 === "arm64" && osPlatform === "darwin") {
+        const model = execSync("sysctl -n machdep.cpu.brand_string", {
+          encoding: "utf-8"
+        }).trim();
+        gpuType = model;
+        gpuVram = this.estimateAppleSiliconVram(model);
+      } else if (arch2 === "x86_64" || arch2 === "x64") {
+        try {
+          const smiOutput = execSync("nvidia-smi --query-gpu=name,memory.free --format=csv,noheader", {
+            encoding: "utf-8"
+          });
+          const parsed = this.parseNvidiaSmiOutput(smiOutput);
+          gpuType = parsed.name;
+          gpuVram = parsed.vramGb;
+        } catch {
+        }
+      }
+    } catch (error) {
+    }
+    return {
+      os: osString,
+      cpu: {
+        model: cpuModel,
+        cores: cpuCores
+      },
+      memory: {
+        totalGb: Math.round(memoryTotal / 1024 ** 3)
+      },
+      gpu: {
+        type: gpuType,
+        vramGb: gpuVram
+      }
+    };
+  }
+  /**
+  * Get compatible models based on available VRAM
+  */
+  getCompatibleModels(vramGb, allModels = []) {
+    if (!allModels || allModels.length === 0) {
+      const defaultModels = [
+        {
+          name: "qwen2.5-3b",
+          minVram: 4,
+          recommendedTier: 2
+        },
+        {
+          name: "qwen2.5-0.5b",
+          minVram: 1,
+          recommendedTier: 1
+        },
+        {
+          name: "gemma-3-1b-web",
+          minVram: 2,
+          recommendedTier: 1
+        },
+        {
+          name: "phi-2",
+          minVram: 2,
+          recommendedTier: 1
+        },
+        {
+          name: "gemma-3-4b",
+          minVram: 4,
+          recommendedTier: 2
+        },
+        {
+          name: "qwen2.5-coder-7b",
+          minVram: 6,
+          recommendedTier: 2
+        },
+        {
+          name: "llama-3.1-8b-instruct",
+          minVram: 10,
+          recommendedTier: 3
+        },
+        {
+          name: "gemma-3-12b",
+          minVram: 10,
+          recommendedTier: 3
+        },
+        {
+          name: "gpt-oss-20b",
+          minVram: 16,
+          recommendedTier: 4
+        },
+        {
+          name: "qwen2.5-coder-32b",
+          minVram: 24,
+          recommendedTier: 4
+        },
+        {
+          name: "glm-4.7-flash",
+          minVram: 24,
+          recommendedTier: 5
+        },
+        {
+          name: "qwen3-coder-30b-a3b",
+          minVram: 24,
+          recommendedTier: 5
+        }
+      ];
+      return defaultModels.filter((model) => model.minVram <= vramGb);
+    }
+    return allModels.filter((model) => model.minVram <= vramGb);
+  }
+  /**
+  * Get recommended tier based on VRAM
+  */
+  getRecommendedTier(vramGb) {
+    if (vramGb >= 80) return 5;
+    if (vramGb >= 48) return 5;
+    if (vramGb >= 24) return 4;
+    if (vramGb >= 16) return 4;
+    if (vramGb >= 14) return 3;
+    if (vramGb >= 10) return 3;
+    if (vramGb >= 6) return 2;
+    if (vramGb >= 1) return 1;
+    return 0;
+  }
+  /**
+  * Detect if this node can participate in CPU inference tasks.
+  *
+  * Requirements:
+  * - At least 2 CPU cores
+  * - At least 4 GB RAM
+  *
+  * Returns true when both conditions are met.
+  */
+  canInference() {
+    const hw = this.detectHardware(true);
+    return hw.cpuCores >= 2 && hw.ramGb >= 4;
+  }
+  /**
+  * Detect if this node can run micro-transformer training.
+  *
+  * Requirements:
+  * - python3 is available in PATH
+  * - torch is importable (PyTorch installed)
+  *
+  * Returns true when both are satisfied.
+  */
+  canTrain() {
+    const python = spawnSync("python3", [
+      "--version"
+    ], {
+      stdio: "pipe"
+    });
+    if (python.status !== 0 || python.error) {
+      return false;
+    }
+    const torchCheck = spawnSync("python3", [
+      "-c",
+      "import torch"
+    ], {
+      stdio: "pipe"
+    });
+    return torchCheck.status === 0 && !torchCheck.error;
+  }
+  /**
+  * Detect if this node can participate in DiLoCo distributed training.
+  *
+  * Requirements:
+  * - GPU or MPS available (gpuVramGb > 0)
+  * - python3 available
+  * - torch importable
+  * - peft importable (LoRA adapters)
+  *
+  * Returns true when all conditions are met.
+  */
+  canDiLoCo(hardware) {
+    const hw = hardware ?? this.detectHardware(false);
+    if (hw.gpuVramGb <= 0) {
+      return false;
+    }
+    const python = spawnSync("python3", [
+      "--version"
+    ], {
+      stdio: "pipe"
+    });
+    if (python.status !== 0 || python.error) {
+      return false;
+    }
+    const torchCheck = spawnSync("python3", [
+      "-c",
+      "import torch"
+    ], {
+      stdio: "pipe"
+    });
+    if (torchCheck.status !== 0 || torchCheck.error) {
+      return false;
+    }
+    const peftCheck = spawnSync("python3", [
+      "-c",
+      "import peft"
+    ], {
+      stdio: "pipe"
+    });
+    return peftCheck.status === 0 && !peftCheck.error;
+  }
+  /**
+  * Build capabilities list from hardware.
+  * Includes 'training' if Python + torch are available.
+  * Includes 'diloco' and 'gpu' if canDiLoCo() returns true.
+  */
+  buildCapabilities(hardware) {
+    const caps = [];
+    if (hardware.cpuCores > 0) caps.push("cpu");
+    if (hardware.gpuVramGb > 0) caps.push("gpu");
+    if (this.canTrain()) {
+      caps.push("training");
+      if (hardware.gpuVramGb > 0) caps.push("gpu_training");
+    }
+    if (this.canDiLoCo(hardware)) {
+      if (!caps.includes("diloco")) caps.push("diloco");
+      if (!caps.includes("gpu")) caps.push("gpu");
+    }
+    if (this.canInference()) {
+      caps.push("cpu_inference");
+      if (hardware.gpuVramGb > 0) caps.push("gpu_inference");
+    }
+    return caps;
+  }
+};
+HardwareHelper = _ts_decorate([
+  Injectable()
+], HardwareHelper);
+var detectAppleSilicon = /* @__PURE__ */ __name((hardware, model) => new HardwareHelper().detectAppleSilicon(hardware, model), "detectAppleSilicon");
+var detectNvidiaGPU = /* @__PURE__ */ __name((hardware, smiOutput) => new HardwareHelper().detectNvidiaGPU(hardware, smiOutput), "detectNvidiaGPU");
+var detectHardware = /* @__PURE__ */ __name((cpuOnly, archOverride) => new HardwareHelper().detectHardware(cpuOnly ?? false, archOverride), "detectHardware");
+var getTierName = /* @__PURE__ */ __name((tier) => new HardwareHelper().getTierName(tier), "getTierName");
+var buildOsString = /* @__PURE__ */ __name((platform2, release2, arch2, osType) => new HardwareHelper().buildOsString(platform2, release2, arch2, osType), "buildOsString");
+var estimateAppleSiliconVram = /* @__PURE__ */ __name((model) => new HardwareHelper().estimateAppleSiliconVram(model), "estimateAppleSiliconVram");
+var parseNvidiaSmiOutput = /* @__PURE__ */ __name((smiOutput) => new HardwareHelper().parseNvidiaSmiOutput(smiOutput), "parseNvidiaSmiOutput");
+var getSystemInfo = /* @__PURE__ */ __name((archOverride) => new HardwareHelper().getSystemInfo(archOverride), "getSystemInfo");
+var getCompatibleModels = /* @__PURE__ */ __name((vramGb, allModels) => new HardwareHelper().getCompatibleModels(vramGb, allModels ?? []), "getCompatibleModels");
+var getRecommendedTier = /* @__PURE__ */ __name((vramGb) => new HardwareHelper().getRecommendedTier(vramGb), "getRecommendedTier");
+var canTrain = /* @__PURE__ */ __name(() => new HardwareHelper().canTrain(), "canTrain");
+var canDiLoCo = /* @__PURE__ */ __name((hardware) => new HardwareHelper().canDiLoCo(hardware), "canDiLoCo");
+var canInference = /* @__PURE__ */ __name(() => new HardwareHelper().canInference(), "canInference");
+var buildCapabilities = /* @__PURE__ */ __name((hardware) => new HardwareHelper().buildCapabilities(hardware), "buildCapabilities");
+
+export {
+  HardwareHelper,
+  detectAppleSilicon,
+  detectNvidiaGPU,
+  detectHardware,
+  getTierName,
+  buildOsString,
+  estimateAppleSiliconVram,
+  parseNvidiaSmiOutput,
+  getSystemInfo,
+  getCompatibleModels,
+  getRecommendedTier,
+  canTrain,
+  canDiLoCo,
+  canInference,
+  buildCapabilities
+};