omnius 1.0.695 → 1.0.697

package/dist/python-cuda-runtime.js

@@ -0,0 +1,512 @@
+import { createRequire as __omnius_createRequire } from "node:module"; import { fileURLToPath as __omnius_fileURLToPath } from "node:url"; import { dirname as __omnius_dirname } from "node:path"; const require = __omnius_createRequire(import.meta.url); const __filename = __omnius_fileURLToPath(import.meta.url); const __dirname = __omnius_dirname(__filename);
+
+// packages/execution/src/python-cuda-runtime.ts
+import { spawnSync } from "node:child_process";
+import { existsSync as existsSync2, mkdirSync, readFileSync as readFileSync2, readdirSync, rmSync, writeFileSync } from "node:fs";
+import { arch, homedir, platform as platform2 } from "node:os";
+import { dirname, join as join2 } from "node:path";
+
+// packages/execution/src/jetson-monitor.ts
+import { existsSync, readFileSync } from "node:fs";
+import { platform } from "node:os";
+var _isJetsonHost = null;
+function isJetsonHost() {
+  if (_isJetsonHost !== null) return _isJetsonHost;
+  if (platform() !== "linux") {
+    _isJetsonHost = false;
+    return false;
+  }
+  if (existsSync("/etc/nv_tegra_release") || existsSync("/sys/module/tegra_fuse")) {
+    _isJetsonHost = true;
+    return true;
+  }
+  try {
+    const model = readFileSync("/proc/device-tree/model", "utf8").replace(/\0/g, " ");
+    _isJetsonHost = /\b(nvidia|jetson|orin|tegra)\b/i.test(model);
+  } catch {
+    _isJetsonHost = false;
+  }
+  return _isJetsonHost;
+}
+
+// packages/execution/src/venv-paths.ts
+import { join } from "node:path";
+var isWin = process.platform === "win32";
+function venvPython(venvDir) {
+  return isWin ? join(venvDir, "Scripts", "python.exe") : join(venvDir, "bin", "python");
+}
+
+// packages/execution/src/python-cuda-runtime.ts
+function managedVenvUsesSystemSitePackages(venvDir) {
+  try {
+    const value = readFileSync2(join2(venvDir, "pyvenv.cfg"), "utf8");
+    const match = value.match(/^include-system-site-packages\s*=\s*(true|false)\s*$/mi);
+    if (!match) return void 0;
+    return match[1]?.toLowerCase() === "true";
+  } catch {
+    return void 0;
+  }
+}
+function run(command, args, timeout, env) {
+  const result = spawnSync(command, args, {
+    encoding: "utf8",
+    env,
+    timeout,
+    maxBuffer: 16 * 1024 * 1024
+  });
+  const output = `${result.stdout ?? ""}
+${result.stderr ?? ""}`.trim();
+  return {
+    ok: !result.error && result.status === 0,
+    output: result.error ? `${output}
+${result.error.message}`.trim() : output
+  };
+}
+function isNvidiaArmCudaHost() {
+  if (platform2() !== "linux" || !["arm64", "arm"].includes(arch())) return false;
+  return isJetsonHost() || existsSync2("/usr/local/cuda/targets/aarch64-linux") || Boolean(process.env["JETSON_L4T_VERSION"]);
+}
+function probeCudaTorchSync(python, env = process.env) {
+  const code = [
+    "import json,torch",
+    "assert torch.cuda.is_available(), f'CUDA unavailable (torch={torch.__version__}, torch_cuda={torch.version.cuda})'",
+    "p=torch.cuda.get_device_properties(0)",
+    "free,total=torch.cuda.mem_get_info(0)",
+    "major,minor=torch.cuda.get_device_capability(0)",
+    "print(json.dumps({'torch':torch.__version__,'torchCuda':torch.version.cuda,'torchFile':torch.__file__,'device':p.name,'major':major,'minor':minor,'total':total,'free':free}))"
+  ].join(";");
+  const result = run(python, ["-c", code], 6e4, env);
+  if (!result.ok) return { ok: false, python, output: result.output };
+  try {
+    const line = result.output.split(/\r?\n/).slice().reverse().find((value) => value.trim().startsWith("{"));
+    const parsed = JSON.parse(line || "{}");
+    return {
+      ok: true,
+      python,
+      output: result.output,
+      torchVersion: parsed.torch,
+      torchCudaVersion: parsed.torchCuda,
+      deviceName: parsed.device,
+      computeCapability: Number(`${parsed.major ?? 0}.${parsed.minor ?? 0}`),
+      totalMemoryBytes: Number(parsed.total ?? 0),
+      freeMemoryBytes: Number(parsed.free ?? 0),
+      torchModulePath: parsed.torchFile
+    };
+  } catch {
+    return { ok: false, python, output: `Invalid CUDA Torch probe output: ${result.output}` };
+  }
+}
+function resolveVendorCudaPythonSync(preferredPython = "python3", env = process.env) {
+  const candidates = [
+    env["OMNIUS_JETPACK_PYTHON"]?.trim(),
+    env["OMNIUS_CUDA_PYTHON"]?.trim(),
+    preferredPython.trim()
+  ];
+  const userHome = homedir();
+  candidates.push(
+    join2(userHome, ".venv", "bin", "python"),
+    join2(userHome, ".venv", "bin", "python3")
+  );
+  for (const parent of ["Documents", "Projects", "projects", "workspace"]) {
+    const root = join2(userHome, parent);
+    try {
+      for (const entry of readdirSync(root, { withFileTypes: true }).slice(0, 256)) {
+        if (!entry.isDirectory()) continue;
+        candidates.push(
+          join2(root, entry.name, ".venv", "bin", "python"),
+          join2(root, entry.name, ".venv", "bin", "python3"),
+          join2(root, entry.name, "venv", "bin", "python"),
+          join2(root, entry.name, "venv", "bin", "python3")
+        );
+      }
+    } catch {
+    }
+  }
+  const nestedRoots = ["Documents", "Projects", "projects", "workspace", "Work", "src"].map((name) => join2(userHome, name));
+  const pending = nestedRoots.map((root) => ({ root, depth: 0 }));
+  const skipped = /* @__PURE__ */ new Set([".git", ".cache", ".npm", ".pnpm-store", "node_modules", "dist", "build", "models", "runtimes"]);
+  let inspected = 0;
+  while (pending.length > 0 && inspected < 768) {
+    const current = pending.shift();
+    inspected++;
+    try {
+      const entries = readdirSync(current.root, { withFileTypes: true }).slice(0, 256);
+      for (const entry of entries) {
+        if (!entry.isDirectory() || skipped.has(entry.name)) continue;
+        const child = join2(current.root, entry.name);
+        if (entry.name === ".venv" || entry.name === "venv") {
+          candidates.push(join2(child, "bin", "python"), join2(child, "bin", "python3"));
+          continue;
+        }
+        if (entry.name.startsWith(".") || current.depth >= 4) continue;
+        pending.push({ root: child, depth: current.depth + 1 });
+      }
+    } catch {
+    }
+  }
+  candidates.push(
+    "/usr/bin/python3",
+    "/usr/local/bin/python3",
+    "python3"
+  );
+  const availableCandidates = candidates.filter((candidate) => {
+    if (!candidate) return false;
+    return !candidate.includes("/") || existsSync2(candidate);
+  });
+  const seen = /* @__PURE__ */ new Set();
+  let firstFailure = null;
+  for (const candidate of availableCandidates) {
+    if (seen.has(candidate)) continue;
+    seen.add(candidate);
+    const probe = probeCudaTorchSync(candidate, env);
+    if (probe.ok) return probe;
+    firstFailure ??= probe;
+  }
+  return firstFailure ?? {
+    ok: false,
+    python: preferredPython,
+    output: "No Python interpreter candidate exposed CUDA-enabled vendor Torch"
+  };
+}
+function readFirst(paths) {
+  for (const path of paths) {
+    try {
+      const value = readFileSync2(path, "utf8").replace(/\0/g, " ").trim();
+      if (value) return value;
+    } catch {
+    }
+  }
+  return void 0;
+}
+function detectCudaToolkitVersion(env) {
+  const versionJson = readFirst(["/usr/local/cuda/version.json"]);
+  if (versionJson) {
+    try {
+      const parsed = JSON.parse(versionJson);
+      const version = parsed.cuda?.version ?? parsed.version;
+      if (version) return String(version);
+    } catch {
+    }
+  }
+  const versionText = readFirst(["/usr/local/cuda/version.txt"]);
+  const textMatch = versionText?.match(/CUDA\s+Version\s+([0-9.]+)/i);
+  if (textMatch?.[1]) return textMatch[1];
+  for (const nvccPath of ["/usr/local/cuda-12.2/bin/nvcc", "/usr/local/cuda/bin/nvcc", "nvcc"]) {
+    const nvcc = run(nvccPath, ["--version"], 15e3, env);
+    const match = nvcc.output.match(/release\s+([0-9.]+)/i)?.[1];
+    if (match) return match;
+  }
+  return void 0;
+}
+function classifyNvidiaArmEnvironmentSync(preferredPython = "python3", env = process.env) {
+  const nvidiaArm = isNvidiaArmCudaHost();
+  const reasons = [];
+  const boardModel = readFirst(["/proc/device-tree/model"]);
+  const family = /orin/i.test(boardModel ?? "") ? "orin" : /thor/i.test(boardModel ?? "") ? "thor" : /xavier/i.test(boardModel ?? "") ? "xavier" : "unknown";
+  const l4tText = readFirst(["/etc/nv_tegra_release"]);
+  const l4tMatch = l4tText?.match(/R(\d+).*REVISION:\s*([0-9.]+)/i);
+  const l4tRelease = l4tMatch ? `${l4tMatch[1]}.${l4tMatch[2]}` : void 0;
+  const l4tMajor = Number(l4tMatch?.[1] ?? 0);
+  const l4tRevision = Number(l4tMatch?.[2] ?? 0);
+  const jetPackMajor = l4tMajor >= 38 ? 7 : l4tMajor >= 36 ? 6 : l4tMajor >= 34 ? 5 : l4tMajor === 32 ? 4 : void 0;
+  const jetPackPackage = run(
+    "dpkg-query",
+    ["-W", "-f=${Version}", "nvidia-jetpack"],
+    15e3,
+    env
+  );
+  const jetPackVersion = jetPackPackage.ok ? jetPackPackage.output.match(/\d+\.\d+(?:\.\d+)?/)?.[0] : void 0;
+  const jetPackFamily = l4tMajor >= 38 ? "7.x" : l4tMajor >= 36 ? l4tRevision >= 4 ? "6.2+" : "6.0/6.1" : l4tMajor === 35 ? "5.x" : l4tMajor === 32 ? "4.x" : void 0;
+  const cudaToolkitVersion = detectCudaToolkitVersion(env);
+  const vendor = resolveVendorCudaPythonSync(preferredPython, env);
+  const pythonInfo = run(
+    vendor.python || preferredPython,
+    ["-c", "import sys;print(f'{sys.version_info.major}.{sys.version_info.minor} cp{sys.version_info.major}{sys.version_info.minor}')"],
+    3e4,
+    env
+  );
+  const pythonTokens = pythonInfo.ok ? pythonInfo.output.trim().split(/\s+/).slice(-2) : [];
+  const pythonVersion = pythonTokens[0];
+  const pythonAbi = pythonTokens[1];
+  const managedTorchProviders = [];
+  const cudaIndexMatch = cudaToolkitVersion?.match(/^(\d+)\.(\d+)/);
+  if (nvidiaArm && jetPackMajor && cudaIndexMatch) {
+    const cudaIndexTag = `cu${cudaIndexMatch[1]}${cudaIndexMatch[2]}`;
+    if (jetPackMajor >= 6) {
+      managedTorchProviders.push({
+        id: "jetson-ai-lab-index",
+        mode: "index",
+        location: `https://pypi.jetson-ai-lab.io/jp${jetPackMajor}/${cudaIndexTag}`
+      });
+    }
+    if (jetPackVersion) {
+      managedTorchProviders.push({
+        id: "nvidia-jetpack-index",
+        mode: "find-links",
+        location: `https://developer.download.nvidia.com/compute/redist/jp/v${jetPackVersion.replace(/\D/g, "")}/pytorch/`
+      });
+    }
+  }
+  const yuyiCompatible = nvidiaArm && !vendor.ok && family === "orin" && l4tMajor === 36 && l4tRevision >= 4 && cudaToolkitVersion?.startsWith("12.6") === true && pythonVersion === "3.10" && (vendor.computeCapability === 8.7 || !vendor.ok && family === "orin");
+  if (yuyiCompatible) {
+    managedTorchProviders.unshift({
+      id: "yuyirobotlab-orin-cu126-vllm-0.19.0",
+      mode: "wheel",
+      location: "https://github.com/YuyiRobotLab/vllm-orin-release/releases/download/v0.19.0-orin/torch-2.10.0-cp310-cp310-linux_aarch64.whl"
+    });
+    reasons.push("Exact Orin SM 8.7 / L4T 36.4+ / CUDA 12.6 / CPython 3.10 provider match");
+  }
+  if (vendor.ok) {
+    reasons.push("No exact binary provider matches every hardware/runtime dimension");
+    reasons.push("CUDA-enabled vendor Torch is available for a source build");
+    return {
+      nvidiaArm,
+      family,
+      boardModel,
+      l4tRelease,
+      jetPackMajor,
+      jetPackVersion,
+      jetPackFamily,
+      cudaToolkitVersion,
+      pythonVersion,
+      pythonAbi,
+      computeCapability: vendor.computeCapability,
+      vendorPython: vendor.python,
+      vendorTorchVersion: vendor.torchVersion,
+      vendorTorchCudaVersion: vendor.torchCudaVersion,
+      recommendedStrategy: "source-existing-torch",
+      managedTorchProviders,
+      reasons
+    };
+  }
+  if (managedTorchProviders.length > 0) {
+    reasons.push("No CUDA-enabled vendor Torch interpreter was found");
+    reasons.push(`Managed CUDA Torch providers: ${managedTorchProviders.map((provider) => provider.id).join(", ")}`);
+    return {
+      nvidiaArm,
+      family,
+      boardModel,
+      l4tRelease,
+      jetPackMajor,
+      jetPackVersion,
+      jetPackFamily,
+      cudaToolkitVersion,
+      pythonVersion,
+      pythonAbi,
+      computeCapability: family === "orin" ? 8.7 : vendor.computeCapability,
+      vendorPython: vendor.python,
+      recommendedStrategy: "managed-torch",
+      matchedProvider: managedTorchProviders[0]?.id,
+      managedTorchProviders,
+      reasons
+    };
+  }
+  reasons.push("No CUDA-enabled vendor Torch interpreter was found");
+  return {
+    nvidiaArm,
+    family,
+    boardModel,
+    l4tRelease,
+    jetPackMajor,
+    jetPackVersion,
+    jetPackFamily,
+    cudaToolkitVersion,
+    pythonVersion,
+    pythonAbi,
+    recommendedStrategy: "unsupported",
+    reasons
+  };
+}
+function ensureCudaPythonVenvSync(options) {
+  const env = { ...process.env, ...options.env };
+  const preferredPython = options.bootstrapPython?.trim() || "python3";
+  const managedPython = venvPython(options.venvDir);
+  const nvidiaArm = isNvidiaArmCudaHost();
+  const requireHost = options.requireHostCudaTorch ?? nvidiaArm;
+  const label = options.label?.trim() || "managed CUDA Python runtime";
+  const host = nvidiaArm ? resolveVendorCudaPythonSync(preferredPython, env) : probeCudaTorchSync(preferredPython, env);
+  const classification = nvidiaArm ? classifyNvidiaArmEnvironmentSync(preferredPython, env) : void 0;
+  const managedProviders = classification?.managedTorchProviders ?? [];
+  const allowManagedTorchInstall = options.allowManagedTorchInstall ?? true;
+  const includeSystemSitePackages = options.includeSystemSitePackages ?? true;
+  const bootstrapPython = host.ok ? host.python : preferredPython;
+  if (requireHost && !host.ok && (!allowManagedTorchInstall || managedProviders.length === 0)) {
+    throw new Error(
+      `${label} requires compatible CUDA Torch, but no vendor installation or environment-matched provider was found: ${host.output}`
+    );
+  }
+  let repaired = false;
+  if (existsSync2(managedPython)) {
+    const current = probeCudaTorchSync(managedPython, env);
+    const isolationMismatch = managedVenvUsesSystemSitePackages(options.venvDir) !== includeSystemSitePackages;
+    if ((options.repairIncompatibleVenv ?? true) && (isolationMismatch || host.ok && !current.ok)) {
+      rmSync(options.venvDir, { recursive: true, force: true });
+      repaired = true;
+    }
+  }
+  if (!existsSync2(managedPython)) {
+    mkdirSync(dirname(options.venvDir), { recursive: true });
+    const created = run(
+      bootstrapPython,
+      [
+        "-m",
+        "venv",
+        ...includeSystemSitePackages ? ["--system-site-packages"] : [],
+        options.venvDir
+      ],
+      12e4,
+      env
+    );
+    if (!created.ok) throw new Error(`Failed to create ${label}: ${created.output}`);
+    if (managedVenvUsesSystemSitePackages(options.venvDir) !== includeSystemSitePackages) {
+      throw new Error(
+        `${label} venv did not retain include-system-site-packages=${includeSystemSitePackages}; refusing an ambiguous Python dependency boundary`
+      );
+    }
+  }
+  let managed = probeCudaTorchSync(managedPython, env);
+  if (!managed.ok && host.ok && host.torchModulePath) {
+    const siteProbe = run(
+      managedPython,
+      ["-c", "import json,site;print(json.dumps(site.getsitepackages()))"],
+      3e4,
+      env
+    );
+    try {
+      const line = siteProbe.output.split(/\r?\n/).slice().reverse().find((value) => value.trim().startsWith("["));
+      const managedSites = JSON.parse(line || "[]");
+      const managedSite = managedSites[0];
+      if (managedSite) {
+        const vendorSite = dirname(dirname(host.torchModulePath));
+        writeFileSync(join2(managedSite, "omnius-vendor-torch.pth"), `${vendorSite}
+`, "utf8");
+        managed = probeCudaTorchSync(managedPython, env);
+      }
+    } catch {
+    }
+  }
+  let torchProvider;
+  if (!managed.ok && allowManagedTorchInstall && managedProviders.length > 0) {
+    const providerEnv = { ...env };
+    delete providerEnv["PIP_CONSTRAINT"];
+    const failures = [];
+    for (const provider of managedProviders) {
+      const providerArgs = provider.mode === "wheel" ? ["-m", "pip", "install", "--disable-pip-version-check", "--no-deps", "--force-reinstall", provider.location] : provider.mode === "index" ? ["-m", "pip", "install", "--disable-pip-version-check", "--upgrade", "--force-reinstall", "--index-url", provider.location, "torch"] : ["-m", "pip", "install", "--disable-pip-version-check", "--upgrade", "--force-reinstall", "--no-index", "--find-links", provider.location, "--no-deps", "torch"];
+      const installed = run(managedPython, providerArgs, 12e5, providerEnv);
+      if (!installed.ok) {
+        failures.push(`${provider.id}: ${installed.output}`);
+        continue;
+      }
+      const candidate = probeCudaTorchSync(managedPython, providerEnv);
+      if (!candidate.ok) {
+        failures.push(`${provider.id}: installed Torch failed CUDA validation: ${candidate.output}`);
+        continue;
+      }
+      managed = candidate;
+      torchProvider = provider.id;
+      break;
+    }
+    if (!managed.ok && requireHost) {
+      throw new Error(
+        `${label} could not install CUDA Torch for ${classification?.jetPackFamily ?? "detected JetPack"} / CUDA ${classification?.cudaToolkitVersion ?? "unknown"} / ${classification?.pythonAbi ?? "unknown ABI"}: ${failures.join("; ")}`
+      );
+    }
+  }
+  const companions = [...new Set(options.cudaCompanionPackages ?? [])].filter((name) => name.trim() && name.trim().toLowerCase() !== "torch");
+  if (managed.ok && nvidiaArm && companions.length > 0) {
+    const companionImports = companions.map((name) => name.replace(/-/g, "_"));
+    const importProbe = () => run(
+      managedPython,
+      ["-c", `import ${companionImports.join(",")}`],
+      6e4,
+      env
+    );
+    if (!importProbe().ok) {
+      const failures = [];
+      for (const provider of managedProviders.filter((candidate) => candidate.mode !== "wheel")) {
+        const providerArgs = provider.mode === "index" ? ["-m", "pip", "install", "--disable-pip-version-check", "--no-deps", "--upgrade", "--index-url", provider.location, ...companions] : ["-m", "pip", "install", "--disable-pip-version-check", "--no-deps", "--upgrade", "--no-index", "--find-links", provider.location, ...companions];
+        const installed = run(managedPython, providerArgs, 12e5, env);
+        if (installed.ok && importProbe().ok) break;
+        failures.push(`${provider.id}: ${installed.output}`);
+      }
+      const verified = importProbe();
+      if (!verified.ok && requireHost) {
+        throw new Error(
+          `${label} could not resolve CUDA companion packages (${companions.join(", ")}) for ${classification?.jetPackFamily ?? "detected JetPack"}: ${failures.join("; ") || verified.output}`
+        );
+      }
+    }
+  }
+  if (requireHost && !managed.ok) {
+    throw new Error(`${label} cannot inherit CUDA Torch from ${bootstrapPython}: ${managed.output}`);
+  }
+  const pipEnv = { ...env };
+  const protectedTorch = managed.ok ? managed : host;
+  if (protectedTorch.ok && protectedTorch.torchVersion) {
+    const constraintPath = join2(options.venvDir, "omnius-cuda-constraints.txt");
+    writeFileSync(
+      constraintPath,
+      `torch===${protectedTorch.torchVersion}
+# Omnius protects environment-matched CUDA Torch from pip replacement.
+`,
+      "utf8"
+    );
+    writeFileSync(
+      join2(options.venvDir, process.platform === "win32" ? "pip.ini" : "pip.conf"),
+      `[global]
+constraint = ${constraintPath}
+`,
+      "utf8"
+    );
+    pipEnv["PIP_CONSTRAINT"] = constraintPath;
+  }
+  return {
+    venvDir: options.venvDir,
+    python: managedPython,
+    bootstrapPython,
+    nvidiaArm,
+    repaired,
+    host,
+    managed,
+    pipEnv,
+    torchProvider
+  };
+}
+var CUDA_RUNTIME_PACKAGES = /* @__PURE__ */ new Set([
+  "torch",
+  "torchvision",
+  "torchaudio",
+  "triton",
+  "vllm",
+  "vllm-omni",
+  "xformers",
+  "flash-attn"
+]);
+function packageName(spec) {
+  return spec.trim().match(/^([a-zA-Z0-9_.-]+)/)?.[1]?.toLowerCase().replace(/_/g, "-") ?? "";
+}
+function cudaSafePipInstallArgs(specs, options = {}) {
+  if (isNvidiaArmCudaHost() && !options.noDeps && specs.some((spec) => CUDA_RUNTIME_PACKAGES.has(packageName(spec)))) {
+    throw new Error(
+      "NVIDIA ARM CUDA packages must use --no-deps or a source build bound to vendor Torch"
+    );
+  }
+  return [
+    "-m",
+    "pip",
+    "install",
+    "--disable-pip-version-check",
+    ...options.upgrade ? ["--upgrade"] : [],
+    ...options.noDeps ? ["--no-deps"] : [],
+    ...specs
+  ];
+}
+export {
+  classifyNvidiaArmEnvironmentSync,
+  cudaSafePipInstallArgs,
+  ensureCudaPythonVenvSync,
+  isNvidiaArmCudaHost,
+  managedVenvUsesSystemSitePackages,
+  probeCudaTorchSync,
+  resolveVendorCudaPythonSync
+};