@wiremock/npm-jar-wrapper-maker 1.0.0

package/LICENSE

@@ -0,0 +1,190 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to the Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   Copyright 2024 WireMock Inc.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -0,0 +1,190 @@
+# npm-jar-wrapper-maker
+
+Create NPM wrappers for Java JARs with automatic JRE management.
+
+This tool generates NPM packages that wrap Java JAR files, allowing them to be distributed and run via `npm install` without requiring users to manually install Java. If Java is not found on the system, the wrapper will automatically download and cache a JRE from Adoptium.
+
+## Installation
+
+```bash
+npm install -g npm-jar-wrapper-maker
+```
+
+Or as a dev dependency in your Java project:
+
+```bash
+npm install --save-dev npm-jar-wrapper-maker
+```
+
+## Usage
+
+### CLI Usage
+
+#### Initialize a Configuration File
+
+```bash
+npm-jar-wrapper-maker --init
+```
+
+This creates a `wrapper-config.json` file that you can customize.
+
+#### Generate from Configuration File
+
+```bash
+npm-jar-wrapper-maker --config wrapper-config.json --output ./npm-package
+```
+
+#### Generate with Inline Options
+
+```bash
+npm-jar-wrapper-maker \
+  --package-name @myorg/my-cli \
+  --cli-name my-cli \
+  --jar-file-name my-app.jar \
+  --java-version 17 \
+  --output ./npm-package
+```
+
+### Programmatic Usage
+
+```javascript
+const { generateWrapper, validateConfig } = require('npm-jar-wrapper-maker');
+
+const config = {
+  packageName: '@myorg/my-cli',
+  version: '1.0.0',
+  description: 'My Java CLI tool',
+  cliName: 'my-cli',
+  jarFileName: 'my-app.jar',
+  targetJavaVersion: 17,
+  author: 'Your Name',
+  license: 'Apache-2.0',
+};
+
+// Validate configuration
+const validation = validateConfig(config);
+if (!validation.valid) {
+  console.error('Invalid config:', validation.errors);
+  process.exit(1);
+}
+
+// Generate the wrapper
+const result = generateWrapper(config, './output-dir');
+
+console.log('Generated files:', result.files);
+console.log('Copy your JAR to:', result.jarPlaceholder);
+```
+
+## Configuration Options
+
+| Option | Type | Required | Default | Description |
+|--------|------|----------|---------|-------------|
+| `packageName` | string | Yes | - | NPM package name (e.g., `@myorg/my-cli`) |
+| `cliName` | string | Yes | - | CLI command name (e.g., `my-cli`) |
+| `jarFileName` | string | Yes | - | JAR file name (e.g., `my-app.jar`) |
+| `version` | string | No | `1.0.0` | Package version |
+| `description` | string | No | `""` | Package description |
+| `author` | string | No | `""` | Package author |
+| `license` | string | No | `Apache-2.0` | Package license |
+| `targetJavaVersion` | number | No | `17` | Target Java version (8+) |
+| `javaOpts` | string[] | No | `[]` | Additional JVM options |
+| `enableNativeAccess` | boolean | No | `false` | Enable Java native access |
+| `enablePostinstall` | boolean | No | `false` | Enable postinstall script |
+| `postinstallCommand` | string | No | `""` | Custom postinstall command |
+| `configDirName` | string | No | Same as `cliName` | Config directory name for JRE cache |
+| `repository` | object | No | `{}` | Repository info for package.json |
+| `homepage` | string | No | `""` | Homepage URL |
+| `bugs` | object | No | `{}` | Bugs URL |
+| `keywords` | string[] | No | `[]` | Additional keywords |
+
+## Generated Files
+
+The generator creates the following files:
+
+- `package.json` - NPM package manifest
+- `index.js` - CLI entry point (with shebang)
+- `cli.js` - Java runtime management and execution logic
+- `.gitignore` - Git ignore rules
+- `.npmignore` - NPM ignore rules
+- `README.md` - Basic documentation
+- `postinstall.js` - (optional) Post-install hook
+
+## How the Generated Wrapper Works
+
+1. When the CLI is executed, it first looks for Java:
+   - Checks `JAVA_HOME` environment variable
+   - Checks for `java` on the system PATH
+   - Checks for a previously downloaded JRE in `~/.config/<cli-name>/jre`
+
+2. If no Java is found, it automatically:
+   - Fetches JRE metadata from Adoptium API
+   - Downloads the appropriate JRE for the user's platform and architecture
+   - Verifies the download checksum
+   - Extracts and caches the JRE locally
+
+3. Executes the JAR file with the found/downloaded Java
+
+## Integration with Gradle/Maven
+
+You can integrate this tool into your Java build process. For example, in a Gradle project:
+
+```groovy
+// build.gradle
+task generateNpmWrapper(type: Exec) {
+    dependsOn bootJar
+
+    commandLine 'npx', 'npm-jar-wrapper-maker',
+        '--package-name', '@myorg/my-cli',
+        '--cli-name', 'my-cli',
+        '--jar-file-name', 'my-cli.jar',
+        '--output', "${buildDir}/npm-wrapper"
+
+    doLast {
+        copy {
+            from bootJar.archiveFile
+            into "${buildDir}/npm-wrapper"
+            rename { 'my-cli.jar' }
+        }
+    }
+}
+```
+
+Or with a configuration file:
+
+```groovy
+task generateNpmWrapper(type: Exec) {
+    dependsOn bootJar
+
+    commandLine 'npx', 'npm-jar-wrapper-maker',
+        '--config', 'npm-wrapper-config.json',
+        '--output', "${buildDir}/npm-wrapper"
+
+    doLast {
+        copy {
+            from bootJar.archiveFile
+            into "${buildDir}/npm-wrapper"
+            rename { 'my-cli.jar' }
+        }
+    }
+}
+```
+
+## Security Features
+
+The generated wrapper includes several security measures:
+
+- **Checksum verification**: Downloaded JREs are verified against SHA256 checksums from Adoptium
+- **Path traversal protection**: Archive extraction rejects paths that could escape the target directory (CVE-2020-12265 mitigation)
+- **HTTPS only**: All downloads use HTTPS
+
+## Supported Platforms
+
+The generated wrappers support:
+
+- macOS (Intel and Apple Silicon)
+- Linux (x64 and ARM64)
+- Windows (x64)
+
+## License
+
+Apache-2.0

package/bin/cli.js

@@ -0,0 +1,291 @@
+#!/usr/bin/env node
+
+/**
+ * npm-jar-wrapper-maker CLI
+ *
+ * Generate NPM wrapper projects for Java JARs.
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { generateWrapper, validateConfig, defaults } = require('../lib/generator');
+
+const USAGE = `
+npm-jar-wrapper-maker - Create NPM wrappers for Java JARs
+
+USAGE:
+  npm-jar-wrapper-maker [options]
+  npm-jar-wrapper-maker --config <config-file>
+  npm-jar-wrapper-maker --init
+
+OPTIONS:
+  --config, -c <file>     Path to configuration JSON file
+  --output, -o <dir>      Output directory (default: ./npm-wrapper)
+  --init                  Create a sample configuration file
+  --help, -h              Show this help message
+  --version, -v           Show version
+
+INLINE OPTIONS (alternative to config file):
+  --package-name <name>   NPM package name (e.g., @org/my-cli)
+  --cli-name <name>       CLI command name (e.g., my-cli)
+  --jar-file-name <name>  JAR file name (e.g., my-app.jar)
+  --java-version <ver>    Target Java version (default: 17)
+  --description <desc>    Package description
+  --version-number <ver>  Package version (default: 1.0.0)
+  --author <author>       Package author
+  --license <license>     Package license (default: Apache-2.0)
+  --enable-postinstall    Enable postinstall script
+  --enable-native-access  Enable Java native access
+
+EXAMPLES:
+  # Initialize a config file
+  npm-jar-wrapper-maker --init
+
+  # Generate from config file
+  npm-jar-wrapper-maker --config wrapper-config.json
+
+  # Generate with inline options
+  npm-jar-wrapper-maker \\
+    --package-name @myorg/my-tool \\
+    --cli-name my-tool \\
+    --jar-file-name my-tool.jar \\
+    --output ./my-tool-npm
+
+  # Generate from config with custom output
+  npm-jar-wrapper-maker -c config.json -o ./dist/npm-package
+`;
+
+const SAMPLE_CONFIG = {
+  packageName: '@myorg/my-java-cli',
+  version: '1.0.0',
+  description: 'My Java CLI tool distributed via NPM',
+  author: 'Your Name',
+  license: 'Apache-2.0',
+  cliName: 'my-java-cli',
+  jarFileName: 'my-java-cli.jar',
+  targetJavaVersion: 17,
+  javaOpts: [],
+  enableNativeAccess: false,
+  enablePostinstall: false,
+  postinstallCommand: '',
+  configDirName: 'my-java-cli',
+  repository: {
+    type: 'git',
+    url: 'https://github.com/myorg/my-java-cli.git',
+  },
+  homepage: 'https://github.com/myorg/my-java-cli',
+  bugs: {
+    url: 'https://github.com/myorg/my-java-cli/issues',
+  },
+  keywords: ['cli', 'tool'],
+};
+
+/**
+ * Parse command line arguments
+ */
+function parseArgs(args) {
+  const parsed = {
+    config: null,
+    output: './npm-wrapper',
+    init: false,
+    help: false,
+    version: false,
+    // Inline options
+    packageName: null,
+    cliName: null,
+    jarFileName: null,
+    targetJavaVersion: null,
+    description: null,
+    versionNumber: null,
+    author: null,
+    license: null,
+    enablePostinstall: false,
+    enableNativeAccess: false,
+  };
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    const next = args[i + 1];
+
+    switch (arg) {
+      case '--config':
+      case '-c':
+        parsed.config = next;
+        i++;
+        break;
+      case '--output':
+      case '-o':
+        parsed.output = next;
+        i++;
+        break;
+      case '--init':
+        parsed.init = true;
+        break;
+      case '--help':
+      case '-h':
+        parsed.help = true;
+        break;
+      case '--version':
+      case '-v':
+        parsed.version = true;
+        break;
+      case '--package-name':
+        parsed.packageName = next;
+        i++;
+        break;
+      case '--cli-name':
+        parsed.cliName = next;
+        i++;
+        break;
+      case '--jar-file-name':
+        parsed.jarFileName = next;
+        i++;
+        break;
+      case '--java-version':
+        parsed.targetJavaVersion = parseInt(next, 10);
+        i++;
+        break;
+      case '--description':
+        parsed.description = next;
+        i++;
+        break;
+      case '--version-number':
+        parsed.versionNumber = next;
+        i++;
+        break;
+      case '--author':
+        parsed.author = next;
+        i++;
+        break;
+      case '--license':
+        parsed.license = next;
+        i++;
+        break;
+      case '--enable-postinstall':
+        parsed.enablePostinstall = true;
+        break;
+      case '--enable-native-access':
+        parsed.enableNativeAccess = true;
+        break;
+      default:
+        if (arg.startsWith('-')) {
+          console.error(`Unknown option: ${arg}`);
+          process.exit(1);
+        }
+    }
+  }
+
+  return parsed;
+}
+
+/**
+ * Build config from parsed arguments
+ */
+function buildConfigFromArgs(parsed) {
+  const config = {};
+
+  if (parsed.packageName) config.packageName = parsed.packageName;
+  if (parsed.cliName) config.cliName = parsed.cliName;
+  if (parsed.jarFileName) config.jarFileName = parsed.jarFileName;
+  if (parsed.targetJavaVersion) config.targetJavaVersion = parsed.targetJavaVersion;
+  if (parsed.description) config.description = parsed.description;
+  if (parsed.versionNumber) config.version = parsed.versionNumber;
+  if (parsed.author) config.author = parsed.author;
+  if (parsed.license) config.license = parsed.license;
+  if (parsed.enablePostinstall) config.enablePostinstall = true;
+  if (parsed.enableNativeAccess) config.enableNativeAccess = true;
+
+  return config;
+}
+
+/**
+ * Main entry point
+ */
+function main() {
+  const args = parseArgs(process.argv.slice(2));
+
+  // Show help
+  if (args.help) {
+    console.log(USAGE);
+    process.exit(0);
+  }
+
+  // Show version
+  if (args.version) {
+    const pkg = require('../package.json');
+    console.log(pkg.version);
+    process.exit(0);
+  }
+
+  // Initialize config file
+  if (args.init) {
+    const configPath = 'wrapper-config.json';
+    if (fs.existsSync(configPath)) {
+      console.error(`Error: ${configPath} already exists`);
+      process.exit(1);
+    }
+    fs.writeFileSync(configPath, JSON.stringify(SAMPLE_CONFIG, null, 2) + '\n');
+    console.log(`Created ${configPath}`);
+    console.log('\nEdit the file and then run:');
+    console.log('  npm-jar-wrapper-maker --config wrapper-config.json');
+    process.exit(0);
+  }
+
+  // Load config
+  let config;
+  if (args.config) {
+    // Load from config file
+    const configPath = path.resolve(args.config);
+    if (!fs.existsSync(configPath)) {
+      console.error(`Error: Config file not found: ${configPath}`);
+      process.exit(1);
+    }
+    try {
+      const configContent = fs.readFileSync(configPath, 'utf-8');
+      config = JSON.parse(configContent);
+    } catch (e) {
+      console.error(`Error parsing config file: ${e.message}`);
+      process.exit(1);
+    }
+  } else if (args.packageName && args.cliName && args.jarFileName) {
+    // Build config from inline options
+    config = buildConfigFromArgs(args);
+  } else {
+    console.error('Error: Either --config or inline options (--package-name, --cli-name, --jar-file-name) are required');
+    console.log('\nRun with --help for usage information');
+    process.exit(1);
+  }
+
+  // Validate config
+  const validation = validateConfig(config);
+  if (!validation.valid) {
+    console.error('Configuration errors:');
+    for (const error of validation.errors) {
+      console.error(`  - ${error}`);
+    }
+    process.exit(1);
+  }
+
+  // Generate wrapper
+  const outputDir = path.resolve(args.output);
+  console.log(`Generating NPM wrapper in: ${outputDir}`);
+
+  try {
+    const result = generateWrapper(config, outputDir);
+    console.log('\nGenerated files:');
+    for (const file of result.files) {
+      console.log(`  - ${path.relative(process.cwd(), file)}`);
+    }
+    console.log(`\nNext steps:`);
+    console.log(`  1. Copy your JAR file to: ${path.relative(process.cwd(), result.jarPlaceholder)}`);
+    console.log(`  2. cd ${path.relative(process.cwd(), outputDir)}`);
+    console.log(`  3. npm install`);
+    console.log(`  4. npm link (for local testing)`);
+    console.log(`  5. npm publish (when ready)`);
+  } catch (e) {
+    console.error(`Error generating wrapper: ${e.message}`);
+    process.exit(1);
+  }
+}
+
+main();