@wiremock/npm-jar-wrapper-maker 1.0.0

package/lib/index.js

@@ -0,0 +1,36 @@
+/**
+ * npm-jar-wrapper-maker
+ *
+ * Create NPM wrappers for Java JARs with automatic JRE management.
+ */
+
+const generator = require('./generator');
+const javaRuntime = require('./java-runtime');
+
+module.exports = {
+  // Generator functions
+  generateWrapper: generator.generateWrapper,
+  generatePackageJson: generator.generatePackageJson,
+  generateIndexJs: generator.generateIndexJs,
+  generateCliJs: generator.generateCliJs,
+  generatePostinstallJs: generator.generatePostinstallJs,
+  generateGitignore: generator.generateGitignore,
+  generateNpmignore: generator.generateNpmignore,
+  generateReadme: generator.generateReadme,
+  validateConfig: generator.validateConfig,
+  defaults: generator.defaults,
+
+  // Java runtime utilities (for advanced use cases)
+  javaRuntime: {
+    findOrDownloadJava: javaRuntime.findOrDownloadJava,
+    runJavaCommand: javaRuntime.runJavaCommand,
+    mapPlatformToOs: javaRuntime.mapPlatformToOs,
+    mapArchToJreArch: javaRuntime.mapArchToJreArch,
+    getUserConfigDir: javaRuntime.getUserConfigDir,
+    isValidArchivePath: javaRuntime.isValidArchivePath,
+    verifyChecksum: javaRuntime.verifyChecksum,
+    checkJavaHome: javaRuntime.checkJavaHome,
+    checkSystemJava: javaRuntime.checkSystemJava,
+    checkManagedJre: javaRuntime.checkManagedJre,
+  },
+};

package/lib/java-runtime.js

@@ -0,0 +1,376 @@
+/**
+ * Java Runtime Management
+ *
+ * Provides functionality for finding, downloading, and managing Java JRE installations.
+ * Supports automatic download from Adoptium API with checksum verification.
+ */
+
+const { spawnSync, execSync } = require('node:child_process');
+const fs = require('node:fs');
+const path = require('node:path');
+const https = require('node:https');
+const crypto = require('node:crypto');
+const os = require('node:os');
+
+/**
+ * Map Node.js platform to JRE OS name
+ */
+function mapPlatformToOs(platform) {
+  switch (platform) {
+    case 'darwin':
+      return 'mac';
+    case 'win32':
+      return 'windows';
+    default:
+      return 'linux';
+  }
+}
+
+/**
+ * Map Node.js architecture to JRE architecture name
+ */
+function mapArchToJreArch(arch) {
+  switch (arch) {
+    case 'arm64':
+      return 'aarch64';
+    case 'x64':
+      return 'x64';
+    case 'ia32':
+      return 'x32';
+    default:
+      return arch;
+  }
+}
+
+/**
+ * Get platform-specific user config directory
+ */
+function getUserConfigDir(platform = process.platform) {
+  switch (platform) {
+    case 'darwin':
+      return path.join(os.homedir(), '.config');
+    case 'win32':
+      return process.env['LOCALAPPDATA'] || path.join(os.homedir(), 'AppData', 'Local');
+    default:
+      return process.env['XDG_CONFIG_HOME'] || path.join(os.homedir(), '.config');
+  }
+}
+
+/**
+ * Check if a path is valid (no path traversal attacks)
+ */
+function isValidArchivePath(filePath) {
+  if (path.isAbsolute(filePath)) {
+    return false;
+  }
+  const segments = filePath.split(path.sep);
+  return !segments.some((segment) => segment === '..');
+}
+
+/**
+ * Verify file checksum
+ */
+function verifyChecksum(filePath, expectedChecksum, algorithm = 'sha256') {
+  const fileBuffer = fs.readFileSync(filePath);
+  const hash = crypto.createHash(algorithm);
+  hash.update(fileBuffer);
+  const actualChecksum = hash.digest('hex');
+  return actualChecksum === expectedChecksum;
+}
+
+/**
+ * Download a file from URL to destination
+ */
+function downloadFile(url, dest) {
+  return new Promise((resolve, reject) => {
+    const file = fs.createWriteStream(dest);
+
+    const request = (url) => {
+      https.get(url, (response) => {
+        if (response.statusCode === 301 || response.statusCode === 302) {
+          // Handle redirects
+          request(response.headers.location);
+          return;
+        }
+
+        if (response.statusCode !== 200) {
+          reject(new Error(`Failed to download: HTTP ${response.statusCode}`));
+          return;
+        }
+
+        response.pipe(file);
+        file.on('finish', () => {
+          file.close(resolve);
+        });
+      }).on('error', (err) => {
+        fs.unlink(dest, () => {}); // Clean up partial file
+        reject(err);
+      });
+    };
+
+    request(url);
+  });
+}
+
+/**
+ * Fetch JSON from URL
+ */
+function fetchJson(url) {
+  return new Promise((resolve, reject) => {
+    const request = (url) => {
+      https.get(url, (response) => {
+        if (response.statusCode === 301 || response.statusCode === 302) {
+          request(response.headers.location);
+          return;
+        }
+
+        if (response.statusCode !== 200) {
+          reject(new Error(`Failed to fetch: HTTP ${response.statusCode}`));
+          return;
+        }
+
+        let data = '';
+        response.on('data', (chunk) => (data += chunk));
+        response.on('end', () => {
+          try {
+            resolve(JSON.parse(data));
+          } catch (e) {
+            reject(new Error(`Failed to parse JSON: ${e.message}`));
+          }
+        });
+      }).on('error', reject);
+    };
+
+    request(url);
+  });
+}
+
+/**
+ * Check if Java is available at JAVA_HOME
+ */
+function checkJavaHome(env) {
+  const javaHome = env.JAVA_HOME;
+  if (!javaHome) {
+    return null;
+  }
+
+  const javaBin = path.join(javaHome, 'bin', 'java');
+  try {
+    if (fs.existsSync(javaBin) || fs.existsSync(javaBin + '.exe')) {
+      return javaHome;
+    }
+  } catch (e) {
+    // Ignore errors
+  }
+  return null;
+}
+
+/**
+ * Check if Java is available on PATH
+ */
+function checkSystemJava() {
+  try {
+    const result = spawnSync('java', ['-version'], {
+      stdio: ['ignore', 'pipe', 'pipe'],
+      timeout: 5000,
+    });
+
+    if (result.status === 0) {
+      // Get the java executable path
+      const whichResult = spawnSync(process.platform === 'win32' ? 'where' : 'which', ['java'], {
+        stdio: ['ignore', 'pipe', 'pipe'],
+      });
+
+      if (whichResult.status === 0) {
+        const javaPath = whichResult.stdout.toString().trim().split('\n')[0];
+        // Return the JAVA_HOME (2 levels up from bin/java)
+        return path.dirname(path.dirname(javaPath));
+      }
+    }
+  } catch (e) {
+    // Ignore errors
+  }
+  return null;
+}
+
+/**
+ * Check if JRE exists in managed directory
+ */
+function checkManagedJre(jreDir) {
+  if (!fs.existsSync(jreDir)) {
+    return null;
+  }
+
+  // Look for java executable in the JRE directory
+  const entries = fs.readdirSync(jreDir);
+  for (const entry of entries) {
+    const entryPath = path.join(jreDir, entry);
+    const stat = fs.statSync(entryPath);
+
+    if (stat.isDirectory()) {
+      // Check common JRE structures
+      const possiblePaths = [
+        path.join(entryPath, 'bin', 'java'),
+        path.join(entryPath, 'Contents', 'Home', 'bin', 'java'),
+      ];
+
+      for (const javaBin of possiblePaths) {
+        if (fs.existsSync(javaBin) || fs.existsSync(javaBin + '.exe')) {
+          // Return the directory containing bin/java
+          return javaBin.includes('Contents/Home')
+            ? path.join(entryPath, 'Contents', 'Home')
+            : entryPath;
+        }
+      }
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Download JRE from Adoptium
+ */
+async function downloadJre(targetVersion, jreDir, platform, arch, onProgress) {
+  const jreOs = mapPlatformToOs(platform);
+  const jreArch = mapArchToJreArch(arch);
+
+  const apiUrl = `https://api.adoptium.net/v3/assets/latest/${targetVersion}/hotspot?architecture=${jreArch}&image_type=jre&os=${jreOs}`;
+
+  if (onProgress) {
+    onProgress({ stage: 'fetching-metadata', message: 'Fetching JRE metadata from Adoptium...' });
+  }
+
+  const assets = await fetchJson(apiUrl);
+
+  if (!assets || assets.length === 0) {
+    throw new Error(`No JRE found for Java ${targetVersion} on ${jreOs}/${jreArch}`);
+  }
+
+  const asset = assets[0];
+  const binary = asset.binary;
+  const downloadUrl = binary.package.link;
+  const checksum = binary.package.checksum;
+  const filename = binary.package.name;
+
+  // Create JRE directory if it doesn't exist
+  fs.mkdirSync(jreDir, { recursive: true });
+
+  const downloadPath = path.join(jreDir, filename);
+
+  if (onProgress) {
+    onProgress({ stage: 'downloading', message: `Downloading JRE from ${downloadUrl}...` });
+  }
+
+  await downloadFile(downloadUrl, downloadPath);
+
+  // Verify checksum
+  if (onProgress) {
+    onProgress({ stage: 'verifying', message: 'Verifying checksum...' });
+  }
+
+  if (!verifyChecksum(downloadPath, checksum)) {
+    fs.unlinkSync(downloadPath);
+    throw new Error('Checksum verification failed');
+  }
+
+  // Extract archive
+  if (onProgress) {
+    onProgress({ stage: 'extracting', message: 'Extracting JRE...' });
+  }
+
+  const decompress = require('decompress');
+  await decompress(downloadPath, jreDir, {
+    filter: (file) => isValidArchivePath(file.path),
+  });
+
+  // Clean up archive
+  fs.unlinkSync(downloadPath);
+
+  // Find and return the extracted JRE path
+  return checkManagedJre(jreDir);
+}
+
+/**
+ * Find or download Java JRE
+ */
+async function findOrDownloadJava(options) {
+  const {
+    targetVersion = 17,
+    jreDir,
+    platform = process.platform,
+    arch = process.arch,
+    env = process.env,
+    onProgress,
+  } = options;
+
+  // Check JAVA_HOME first
+  let javaHome = checkJavaHome(env);
+  if (javaHome) {
+    return javaHome;
+  }
+
+  // Check system Java
+  javaHome = checkSystemJava();
+  if (javaHome) {
+    return javaHome;
+  }
+
+  // Check managed JRE
+  javaHome = checkManagedJre(jreDir);
+  if (javaHome) {
+    return javaHome;
+  }
+
+  // Download JRE
+  return downloadJre(targetVersion, jreDir, platform, arch, onProgress);
+}
+
+/**
+ * Run Java command with the JAR
+ */
+function runJavaCommand(javaHome, jarPath, args, options = {}) {
+  const {
+    javaOpts = [],
+    env = process.env,
+    spawnOptions = { stdio: 'inherit' },
+  } = options;
+
+  const javaBin = path.join(javaHome, 'bin', 'java');
+
+  // Build Java arguments
+  const javaArgs = [
+    '-Dsun.misc.URLClassPath.disableJarChecking=true',
+    ...javaOpts,
+    '-jar',
+    jarPath,
+    ...args,
+  ];
+
+  // Add JAVA_OPTS if set
+  if (env.JAVA_OPTS) {
+    const extraOpts = env.JAVA_OPTS.split(' ').filter(Boolean);
+    javaArgs.unshift(...extraOpts);
+  }
+
+  return spawnSync(javaBin, javaArgs, {
+    ...spawnOptions,
+    env,
+  });
+}
+
+module.exports = {
+  mapPlatformToOs,
+  mapArchToJreArch,
+  getUserConfigDir,
+  isValidArchivePath,
+  verifyChecksum,
+  downloadFile,
+  fetchJson,
+  checkJavaHome,
+  checkSystemJava,
+  checkManagedJre,
+  downloadJre,
+  findOrDownloadJava,
+  runJavaCommand,
+};

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@wiremock/npm-jar-wrapper-maker",
+  "version": "1.0.0",
+  "description": "Create NPM wrappers for Java JARs with automatic JRE management",
+  "main": "lib/index.js",
+  "bin": {
+    "npm-jar-wrapper-maker": "bin/cli.js"
+  },
+  "files": [
+    "lib/",
+    "bin/",
+    "LICENSE"
+  ],
+  "scripts": {
+    "test": "node --test test/*.test.js",
+    "lint": "prettier --check .",
+    "format": "prettier --write ."
+  },
+  "keywords": [
+    "npm",
+    "jar",
+    "java",
+    "wrapper",
+    "cli",
+    "jre",
+    "wiremock"
+  ],
+  "author": "WireMock Inc.",
+  "license": "Apache-2.0",
+  "dependencies": {
+    "decompress": "^4.2.1"
+  },
+  "devDependencies": {
+    "prettier": "^3.2.4"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/wiremock/npm-jar-wrapper-maker.git"
+  },
+  "homepage": "https://github.com/wiremock/npm-jar-wrapper-maker#readme",
+  "bugs": {
+    "url": "https://github.com/wiremock/npm-jar-wrapper-maker/issues"
+  }
+}