onnxruntime-node 1.22.0-dev.20250415-c18e06d5e3 → 1.22.0-rev

package/script/install-utils.js

@@ -0,0 +1,306 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+'use strict';
+
+const fs = require('fs');
+const https = require('https');
+const { execFileSync } = require('child_process');
+const path = require('path');
+const os = require('os');
+const AdmZip = require('adm-zip'); // Use adm-zip instead of spawn
+
+async function downloadFile(url, dest) {
+  return new Promise((resolve, reject) => {
+    const file = fs.createWriteStream(dest);
+    https
+      .get(url, (res) => {
+        if (res.statusCode !== 200) {
+          file.close();
+          fs.unlinkSync(dest);
+          reject(new Error(`Failed to download from ${url}. HTTP status code = ${res.statusCode}`));
+          return;
+        }
+
+        res.pipe(file);
+        file.on('finish', () => {
+          file.close();
+          resolve();
+        });
+        file.on('error', (err) => {
+          fs.unlinkSync(dest);
+          reject(err);
+        });
+      })
+      .on('error', (err) => {
+        fs.unlinkSync(dest);
+        reject(err);
+      });
+  });
+}
+
+async function downloadJson(url) {
+  return new Promise((resolve, reject) => {
+    https
+      .get(url, (res) => {
+        const { statusCode } = res;
+        const contentType = res.headers['content-type'];
+
+        if (!statusCode) {
+          reject(new Error('No response statud code from server.'));
+          return;
+        }
+        if (statusCode >= 400 && statusCode < 500) {
+          resolve(null);
+          return;
+        } else if (statusCode !== 200) {
+          reject(new Error(`Failed to download build list. HTTP status code = ${statusCode}`));
+          return;
+        }
+        if (!contentType || !/^application\/json/.test(contentType)) {
+          reject(new Error(`unexpected content type: ${contentType}`));
+          return;
+        }
+        res.setEncoding('utf8');
+        let rawData = '';
+        res.on('data', (chunk) => {
+          rawData += chunk;
+        });
+        res.on('end', () => {
+          try {
+            resolve(JSON.parse(rawData));
+          } catch (e) {
+            reject(e);
+          }
+        });
+        res.on('error', (err) => {
+          reject(err);
+        });
+      })
+      .on('error', (err) => {
+        reject(err);
+      });
+  });
+}
+
+async function installPackages(packages, manifests, feeds) {
+  // Step.1: resolve packages
+  const resolvedPackages = new Map();
+  for (const packageCandidates of packages) {
+    // iterate all candidates from packagesInfo and try to find the first one that exists
+    for (const { feed, version } of packageCandidates.versions) {
+      const { type, index } = feeds[feed];
+      const pkg = await resolvePackage(type, index, packageCandidates.name, version);
+      if (pkg) {
+        resolvedPackages.set(packageCandidates, pkg);
+        break;
+      }
+    }
+    if (!resolvedPackages.has(packageCandidates)) {
+      throw new Error(`Failed to resolve package. No package exists for: ${JSON.stringify(packageCandidates)}`);
+    }
+  }
+
+  // Step.2: download packages
+  for (const [pkgInfo, pkg] of resolvedPackages) {
+    const manifestsForPackage = manifests.filter((x) => x.packagesInfo === pkgInfo);
+    await pkg.download(manifestsForPackage);
+  }
+}
+
+async function resolvePackage(type, index, packageName, version) {
+  // https://learn.microsoft.com/en-us/nuget/api/overview
+  const nugetPackageUrlResolver = async (index, packageName, version) => {
+    // STEP.1 - get Nuget package index
+    const nugetIndex = await downloadJson(index);
+    if (!nugetIndex) {
+      throw new Error(`Failed to download Nuget index from ${index}`);
+    }
+
+    // STEP.2 - get the base url of "PackageBaseAddress/3.0.0"
+    const packageBaseUrl = nugetIndex.resources.find((x) => x['@type'] === 'PackageBaseAddress/3.0.0')?.['@id'];
+    if (!packageBaseUrl) {
+      throw new Error(`Failed to find PackageBaseAddress in Nuget index`);
+    }
+
+    // STEP.3 - get the package version info
+    const packageInfo = await downloadJson(`${packageBaseUrl}${packageName.toLowerCase()}/index.json`);
+    if (!packageInfo.versions.includes(version.toLowerCase())) {
+      throw new Error(`Failed to find specific package versions for ${packageName} in ${index}`);
+    }
+
+    // STEP.4 - generate the package URL
+    const packageUrl = `${packageBaseUrl}${packageName.toLowerCase()}/${version.toLowerCase()}/${packageName.toLowerCase()}.${version.toLowerCase()}.nupkg`;
+    const packageFileName = `${packageName.toLowerCase()}.${version.toLowerCase()}.nupkg`;
+
+    return {
+      download: async (manifests) => {
+        if (manifests.length === 0) {
+          return;
+        }
+
+        // Create a temporary directory
+        const tempDir = path.join(os.tmpdir(), `onnxruntime-node-pkgs_${Date.now()}`);
+        fs.mkdirSync(tempDir, { recursive: true });
+
+        try {
+          const packageFilePath = path.join(tempDir, packageFileName);
+
+          // Download the NuGet package
+          console.log(`Downloading ${packageUrl}`);
+          await downloadFile(packageUrl, packageFilePath);
+
+          // Load the NuGet package (which is a ZIP file)
+          let zip;
+          try {
+            zip = new AdmZip(packageFilePath);
+          } catch (err) {
+            throw new Error(`Failed to open NuGet package: ${err.message}`);
+          }
+
+          // Extract only the needed files from the package
+          const extractDir = path.join(tempDir, 'extracted');
+          fs.mkdirSync(extractDir, { recursive: true });
+
+          // Process each manifest and extract/copy files to their destinations
+          for (const manifest of manifests) {
+            const { filepath, pathInPackage } = manifest;
+
+            // Create directory for the target file
+            const targetDir = path.dirname(filepath);
+            fs.mkdirSync(targetDir, { recursive: true });
+
+            // Check if the file exists directly in the zip
+            const zipEntry = zip.getEntry(pathInPackage);
+            if (!zipEntry) {
+              throw new Error(`Failed to find ${pathInPackage} in NuGet package`);
+            }
+
+            console.log(`Extracting ${pathInPackage} to ${filepath}`);
+
+            // Extract just this entry to a temporary location
+            const extractedFilePath = path.join(extractDir, path.basename(pathInPackage));
+            zip.extractEntryTo(zipEntry, extractDir, false, true);
+
+            // Copy to the final destination
+            fs.copyFileSync(extractedFilePath, filepath);
+          }
+        } finally {
+          // Clean up the temporary directory - always runs even if an error occurs
+          try {
+            fs.rmSync(tempDir, { recursive: true });
+          } catch (e) {
+            console.warn(`Failed to clean up temporary directory: ${tempDir}`, e);
+            // Don't rethrow this error as it would mask the original error
+          }
+        }
+      },
+    };
+  };
+
+  switch (type) {
+    case 'nuget':
+      return await nugetPackageUrlResolver(index, packageName, version);
+    default:
+      throw new Error(`Unsupported package type: ${type}`);
+  }
+}
+
+function tryGetCudaVersion() {
+  // Should only return 11 or 12.
+
+  // try to get the CUDA version from the system ( `nvcc --version` )
+  let ver = 12;
+  try {
+    const nvccVersion = execFileSync('nvcc', ['--version'], { encoding: 'utf8' });
+    const match = nvccVersion.match(/release (\d+)/);
+    if (match) {
+      ver = parseInt(match[1]);
+      if (ver !== 11 && ver !== 12) {
+        throw new Error(`Unsupported CUDA version: ${ver}`);
+      }
+    }
+  } catch (e) {
+    if (e?.code === 'ENOENT') {
+      console.warn('`nvcc` not found. Assuming CUDA 12.');
+    } else {
+      console.warn('Failed to detect CUDA version from `nvcc --version`:', e.message);
+    }
+  }
+
+  // assume CUDA 12 if failed to detect
+  return ver;
+}
+
+function parseInstallFlag() {
+  let flag = process.env.ONNXRUNTIME_NODE_INSTALL || process.env.npm_config_onnxruntime_node_install;
+  if (!flag) {
+    for (let i = 0; i < process.argv.length; i++) {
+      if (process.argv[i].startsWith('--onnxruntime-node-install=')) {
+        flag = process.argv[i].split('=')[1];
+        break;
+      } else if (process.argv[i] === '--onnxruntime-node-install') {
+        flag = 'true';
+      }
+    }
+  }
+  switch (flag) {
+    case 'true':
+    case '1':
+    case 'ON':
+      return true;
+    case 'skip':
+      return false;
+    case undefined: {
+      flag = parseInstallCudaFlag();
+      if (flag === 'skip') {
+        return false;
+      }
+      if (flag === 11) {
+        throw new Error('CUDA 11 is no longer supported. Please consider using CPU or upgrade to CUDA 12.');
+      }
+      if (flag === 12) {
+        return 'cuda12';
+      }
+      return undefined;
+    }
+    default:
+      if (!flag || typeof flag !== 'string') {
+        throw new Error(`Invalid value for --onnxruntime-node-install: ${flag}`);
+      }
+  }
+}
+
+function parseInstallCudaFlag() {
+  let flag = process.env.ONNXRUNTIME_NODE_INSTALL_CUDA || process.env.npm_config_onnxruntime_node_install_cuda;
+  if (!flag) {
+    for (let i = 0; i < process.argv.length; i++) {
+      if (process.argv[i].startsWith('--onnxruntime-node-install-cuda=')) {
+        flag = process.argv[i].split('=')[1];
+        break;
+      } else if (process.argv[i] === '--onnxruntime-node-install-cuda') {
+        flag = 'true';
+      }
+    }
+  }
+  switch (flag) {
+    case 'true':
+    case '1':
+    case 'ON':
+      return tryGetCudaVersion();
+    case 'v11':
+      return 11;
+    case 'v12':
+      return 12;
+    case 'skip':
+    case undefined:
+      return flag;
+    default:
+      throw new Error(`Invalid value for --onnxruntime-node-install-cuda: ${flag}`);
+  }
+}
+
+module.exports = {
+  installPackages,
+  parseInstallFlag,
+};

package/script/install.js

@@ -1,198 +1,134 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License.
-
-'use strict';
-
-// This script is written in JavaScript. This is because it is used in "install" script in package.json, which is called
-// when the package is installed either as a dependency or from "npm ci"/"npm install" without parameters. TypeScript is
-// not always available.
-
-// The purpose of this script is to download the required binaries for the platform and architecture.
-// Currently, most of the binaries are already bundled in the package, except for the following:
-// - Linux/x64/CUDA 12
-//
-// The CUDA binaries are not bundled because they are too large to be allowed in the npm registry. Instead, they are
-// downloaded from the GitHub release page of ONNX Runtime. The script will download the binaries if they are not
-// already present in the package.
-
-// Step.1: Check if we should exit early
-const os = require('os');
-const fs = require('fs');
-const https = require('https');
-const path = require('path');
-const tar = require('tar');
-const { execFileSync } = require('child_process');
-const { bootstrap: globalAgentBootstrap } = require('global-agent');
-
-// Bootstrap global-agent to honor the proxy settings in
-// environment variables, e.g. GLOBAL_AGENT_HTTPS_PROXY.
-// See https://github.com/gajus/global-agent/blob/v3.0.0/README.md#environment-variables for details.
-globalAgentBootstrap();
-
-// commandline flag:
-// --onnxruntime-node-install-cuda         Force install the CUDA EP binaries. Try to detect the CUDA version.
-// --onnxruntime-node-install-cuda=v11     Force install the CUDA EP binaries for CUDA 11.
-// --onnxruntime-node-install-cuda=v12     Force install the CUDA EP binaries for CUDA 12.
-// --onnxruntime-node-install-cuda=skip    Skip the installation of the CUDA EP binaries.
-//
-// Alternatively, use environment variable "ONNXRUNTIME_NODE_INSTALL_CUDA"
-//
-// If the flag is not provided, the script will only install the CUDA EP binaries when:
-// - The platform is Linux/x64.
-// - The binaries are not already present in the package.
-// - The installation is not a local install (when used inside ONNX Runtime repo).
-//
-const INSTALL_CUDA_FLAG = parseInstallCudaFlag();
-const NO_INSTALL = INSTALL_CUDA_FLAG === 'skip';
-const FORCE_INSTALL = !NO_INSTALL && INSTALL_CUDA_FLAG;
-
-const IS_LINUX_X64 = os.platform() === 'linux' && os.arch() === 'x64';
-const BIN_FOLDER = path.join(__dirname, '..', 'bin/napi-v3/linux/x64');
-const BIN_FOLDER_EXISTS = fs.existsSync(BIN_FOLDER);
-const CUDA_DLL_EXISTS = fs.existsSync(path.join(BIN_FOLDER, 'libonnxruntime_providers_cuda.so'));
-const ORT_VERSION = require('../package.json').version;
-
-const npm_config_local_prefix = process.env.npm_config_local_prefix;
-const npm_package_json = process.env.npm_package_json;
-const SKIP_LOCAL_INSTALL =
-  npm_config_local_prefix && npm_package_json && path.dirname(npm_package_json) === npm_config_local_prefix;
-
-const shouldInstall = FORCE_INSTALL || (!SKIP_LOCAL_INSTALL && IS_LINUX_X64 && BIN_FOLDER_EXISTS && !CUDA_DLL_EXISTS);
-if (NO_INSTALL || !shouldInstall) {
-  process.exit(0);
-}
-
-// Step.2: Download the required binaries
-const artifactUrl = {
-  get 11() {
-    // TODO: support ORT Cuda v11 binaries
-    throw new Error(`CUDA 11 binaries are not supported by this script yet.
-
-To use ONNX Runtime Node.js binding with CUDA v11 support, please follow the manual steps:
-
-1. Use "--onnxruntime-node-install-cuda=skip" to skip the auto installation.
-2. Navigate to https://aiinfra.visualstudio.com/PublicPackages/_artifacts/feed/onnxruntime-cuda-11
-3. Download the binaries for your platform and architecture
-4. Extract the following binaries to "node_modules/onnxruntime-node/bin/napi-v3/linux/x64:
-   - libonnxruntime_providers_tensorrt.so
-   - libonnxruntime_providers_shared.so
-   - libonnxruntime.so.${ORT_VERSION}
-   - libonnxruntime_providers_cuda.so
-`);
-  },
-  12: `https://github.com/microsoft/onnxruntime/releases/download/v${ORT_VERSION}/onnxruntime-linux-x64-gpu-${
-    ORT_VERSION
-  }.tgz`,
-}[INSTALL_CUDA_FLAG || tryGetCudaVersion()];
-console.log(`Downloading "${artifactUrl}"...`);
-
-const FILES = new Set([
-  'libonnxruntime_providers_tensorrt.so',
-  'libonnxruntime_providers_shared.so',
-  `libonnxruntime.so.${ORT_VERSION}`,
-  'libonnxruntime_providers_cuda.so',
-]);
-
-downloadAndExtract(artifactUrl, BIN_FOLDER, FILES);
-
-async function downloadAndExtract(url, dest, files) {
-  return new Promise((resolve, reject) => {
-    https.get(url, (res) => {
-      const { statusCode } = res;
-      const contentType = res.headers['content-type'];
-
-      if (statusCode === 301 || statusCode === 302) {
-        downloadAndExtract(res.headers.location, dest, files).then(
-          (value) => resolve(value),
-          (reason) => reject(reason),
-        );
-        return;
-      } else if (statusCode !== 200) {
-        throw new Error(`Failed to download the binaries: ${res.statusCode} ${res.statusMessage}.
-
-Use "--onnxruntime-node-install-cuda=skip" to skip the installation. You will still be able to use ONNX Runtime, but the CUDA EP will not be available.`);
-      }
-
-      if (!contentType || !/^application\/octet-stream/.test(contentType)) {
-        throw new Error(`unexpected content type: ${contentType}`);
-      }
-
-      res
-        .pipe(
-          tar.t({
-            strict: true,
-            onentry: (entry) => {
-              const filename = path.basename(entry.path);
-              if (entry.type === 'File' && files.has(filename)) {
-                console.log(`Extracting "${filename}" to "${dest}"...`);
-                entry.pipe(fs.createWriteStream(path.join(dest, filename)));
-                entry.on('finish', () => {
-                  console.log(`Finished extracting "${filename}".`);
-                });
-              }
-            },
-          }),
-        )
-        .on('error', (err) => {
-          throw new Error(`Failed to extract the binaries: ${err.message}.
-
-Use "--onnxruntime-node-install-cuda=skip" to skip the installation. You will still be able to use ONNX Runtime, but the CUDA EP will not be available.`);
-        });
-    });
-  });
-}
-
-function tryGetCudaVersion() {
-  // Should only return 11 or 12.
-
-  // try to get the CUDA version from the system ( `nvcc --version` )
-  let ver = 12;
-  try {
-    const nvccVersion = execFileSync('nvcc', ['--version'], { encoding: 'utf8' });
-    const match = nvccVersion.match(/release (\d+)/);
-    if (match) {
-      ver = parseInt(match[1]);
-      if (ver !== 11 && ver !== 12) {
-        throw new Error(`Unsupported CUDA version: ${ver}`);
-      }
-    }
-  } catch (e) {
-    if (e?.code === 'ENOENT') {
-      console.warn('`nvcc` not found. Assuming CUDA 12.');
-    } else {
-      console.warn('Failed to detect CUDA version from `nvcc --version`:', e.message);
-    }
-  }
-
-  // assume CUDA 12 if failed to detect
-  return ver;
-}
-
-function parseInstallCudaFlag() {
-  let flag = process.env.ONNXRUNTIME_NODE_INSTALL_CUDA || process.env.npm_config_onnxruntime_node_install_cuda;
-  if (!flag) {
-    for (let i = 0; i < process.argv.length; i++) {
-      if (process.argv[i].startsWith('--onnxruntime-node-install-cuda=')) {
-        flag = process.argv[i].split('=')[1];
-        break;
-      } else if (process.argv[i] === '--onnxruntime-node-install-cuda') {
-        flag = 'true';
-      }
-    }
-  }
-  switch (flag) {
-    case 'true':
-    case '1':
-    case 'ON':
-      return tryGetCudaVersion();
-    case 'v11':
-      return 11;
-    case 'v12':
-      return 12;
-    case 'skip':
-    case undefined:
-      return flag;
-    default:
-      throw new Error(`Invalid value for --onnxruntime-node-install-cuda: ${flag}`);
-  }
-}
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+'use strict';
+
+// This script is written in JavaScript. This is because it is used in "install" script in package.json, which is called
+// when the package is installed either as a dependency or from "npm ci"/"npm install" without parameters. TypeScript is
+// not always available.
+
+// The purpose of this script is to download the required binaries for the platform and architecture.
+// Currently, most of the binaries are already bundled in the package, except for the files that described in the file
+// install-metadata.js.
+//
+// Some files (eg. the CUDA EP binaries) are not bundled because they are too large to be allowed in the npm registry.
+// Instead, they are downloaded from the Nuget feed. The script will download the binaries if they are not already
+// present in the NPM package.
+
+// Step.1: Check if we should exit early
+const os = require('os');
+const path = require('path');
+const { bootstrap: globalAgentBootstrap } = require('global-agent');
+const { installPackages, parseInstallFlag } = require('./install-utils.js');
+
+const INSTALL_METADATA = require('./install-metadata.js');
+
+// Bootstrap global-agent to honor the proxy settings in
+// environment variables, e.g. GLOBAL_AGENT_HTTPS_PROXY.
+// See https://github.com/gajus/global-agent/blob/v3.0.0/README.md#environment-variables for details.
+globalAgentBootstrap();
+
+// commandline flag:
+//
+// --onnxruntime-node-install              Force install the files that are not bundled in the package.
+//
+// --onnxruntime-node-install=skip         Skip the installation of the files that are not bundled in the package.
+//
+// --onnxruntime-node-install=cuda12       Force install the CUDA EP binaries for CUDA 12.
+//
+// --onnxruntime-node-install-cuda         Force install the CUDA EP binaries.
+//                                         (deprecated, use --onnxruntime-node-install=cuda12)
+//
+// --onnxruntime-node-install-cuda=skip    Skip the installation of the CUDA EP binaries.
+//                                         (deprecated, use --onnxruntime-node-install=skip)
+//
+//
+// Alternatively, use environment variable "ONNXRUNTIME_NODE_INSTALL" or "ONNXRUNTIME_NODE_INSTALL_CUDA" (deprecated).
+//
+// If the flag is not provided, the script will look up the metadata file to determine the manifest.
+//
+
+/**
+ * Possible values:
+ * - undefined: the default behavior. This is the value when no installation flag is specified.
+ *
+ * - false: skip installation. This is the value when the installation flag is set to "skip":
+ *   --onnxruntime-node-install=skip
+ *
+ * - true: force installation. This is the value when the installation flag is set with no value:
+ *   --onnxruntime-node-install
+ *
+ * - string: the installation flag is set to a specific value:
+ *   --onnxruntime-node-install=cuda12
+ */
+const INSTALL_FLAG = parseInstallFlag();
+
+// if installation is skipped, exit early
+if (INSTALL_FLAG === false) {
+  process.exit(0);
+}
+// if installation is not specified, exit early when the installation is local (e.g. `npm ci` in <ORT_ROOT>/js/node/)
+if (INSTALL_FLAG === undefined) {
+  const npm_config_local_prefix = process.env.npm_config_local_prefix;
+  const npm_package_json = process.env.npm_package_json;
+  const IS_LOCAL_INSTALL =
+    npm_config_local_prefix && npm_package_json && path.dirname(npm_package_json) === npm_config_local_prefix;
+  if (IS_LOCAL_INSTALL) {
+    process.exit(0);
+  }
+}
+
+const PLATFORM = `${os.platform()}/${os.arch()}`;
+let INSTALL_MANIFEST_NAMES = INSTALL_METADATA.requirements[PLATFORM] ?? [];
+
+// if installation is specified explicitly, validate the manifest
+if (typeof INSTALL_FLAG === 'string') {
+  const installations = INSTALL_FLAG.split(',').map((x) => x.trim());
+  for (const installation of installations) {
+    if (INSTALL_MANIFEST_NAMES.indexOf(installation) === -1) {
+      throw new Error(`Invalid installation: ${installation} for platform: ${PLATFORM}`);
+    }
+  }
+  INSTALL_MANIFEST_NAMES = installations;
+}
+
+const BIN_FOLDER = path.join(__dirname, '..', 'bin/napi-v6', PLATFORM);
+const INSTALL_MANIFESTS = [];
+
+const PACKAGES = new Set();
+for (const name of INSTALL_MANIFEST_NAMES) {
+  const manifest = INSTALL_METADATA.manifests[`${PLATFORM}:${name}`];
+  if (!manifest) {
+    throw new Error(`Manifest not found: ${name} for platform: ${PLATFORM}`);
+  }
+
+  for (const [filename, { package: pkg, path: pathInPackage }] of Object.entries(manifest)) {
+    const packageCandidates = INSTALL_METADATA.packages[pkg];
+    if (!packageCandidates) {
+      throw new Error(`Package information not found: ${pkg}`);
+    }
+    PACKAGES.add(packageCandidates);
+
+    INSTALL_MANIFESTS.push({
+      filepath: path.normalize(path.join(BIN_FOLDER, filename)),
+      packagesInfo: packageCandidates,
+      pathInPackage,
+    });
+  }
+}
+
+// If the installation flag is not specified, we do a check to see if the files are already installed.
+if (INSTALL_FLAG === undefined) {
+  let hasMissingFiles = false;
+  for (const { filepath } of INSTALL_MANIFESTS) {
+    if (!require('fs').existsSync(filepath)) {
+      hasMissingFiles = true;
+      break;
+    }
+  }
+  if (!hasMissingFiles) {
+    process.exit(0);
+  }
+}
+
+void installPackages(PACKAGES, INSTALL_MANIFESTS, INSTALL_METADATA.feeds);