@lambda-kata/licensing 0.1.6 → 0.1.8

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@lambda-kata/licensing",
-    "version": "0.1.6",
+    "version": "0.1.8",
     "description": "Tamper-resistant native licensing validator for Lambda Kata Integration",
     "main": "out/dist/index.js",
     "types": "out/tsc/index.d.ts",
@@ -48,13 +48,16 @@
         "lint": "eslint src/ test/ --ext .ts",
         "lint:fix": "eslint src/ test/ --ext .ts --fix",
         "docs": "typedoc src/index.ts --out docs/",
-        "_install": "node scripts/install.js",
-        "_postinstall": "node scripts/postinstall.js || echo 'Postinstall script failed, using fallback mode'"
+        "install": "node scripts/install.js",
+        "postinstall": "node scripts/postinstall.js || echo 'Postinstall script failed, using fallback mode'"
     },
     "files": [
         "out/",
+        "prebuilt/",
         "build/amd64/",
         "build/arm64/",
+        "scripts/install.js",
+        "scripts/postinstall.js",
         "README.md",
         "LICENSE"
     ],
@@ -94,4 +97,4 @@
             9
         ]
     }
-}
+}

package/scripts/install.js

@@ -0,0 +1,219 @@
+#!/usr/bin/env node
+/**
+ * Elastic License 2.0
+ *
+ * Copyright (c) 2024 Lambda Kata Team, Raman Marozau raman@worktif.com
+ *
+ * npm install script for native licensing validator
+ * Handles prebuilt binary selection and fallback logic
+ *
+ * @remarks Validates: Requirements 5.6
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+// Configuration
+const PACKAGE_NAME = '@lambda-kata/licensing';
+const ADDON_NAME = 'lambda_kata_licensing.node';
+
+// Platform mapping
+const PLATFORM_MAP = {
+  'linux-x64': 'amd64',
+  'linux-arm64': 'arm64'
+};
+
+// Colors for output
+const colors = {
+  red: '\x1b[31m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+  reset: '\x1b[0m'
+};
+
+function log(level, message) {
+  const timestamp = new Date().toISOString();
+  const color = colors[level] || colors.reset;
+  console.log(`${color}[${level.toUpperCase()}]${colors.reset} ${timestamp} ${message}`);
+}
+
+function getPlatformKey() {
+  const platform = os.platform();
+  const arch = os.arch();
+
+  // Only support Linux for Lambda deployment
+  if (platform !== 'linux') {
+    return null;
+  }
+
+  // Map Node.js arch to our naming convention
+  const archMap = {
+    'x64': 'x64',
+    'arm64': 'arm64'
+  };
+
+  const mappedArch = archMap[arch];
+  if (!mappedArch) {
+    return null;
+  }
+
+  return `${platform}-${mappedArch}`;
+}
+
+function getPrebuiltPath() {
+  const platformKey = getPlatformKey();
+  if (!platformKey) {
+    return null;
+  }
+
+  const mappedArch = PLATFORM_MAP[platformKey];
+  if (!mappedArch) {
+    return null;
+  }
+
+  // Look for prebuilt binary in prebuilt directory (shipped with npm package)
+  const prebuiltDir = path.join(__dirname, '..', 'prebuilt');
+  const prebuiltPath = path.join(prebuiltDir, mappedArch, 'build', 'Release', ADDON_NAME);
+
+  if (fs.existsSync(prebuiltPath)) {
+    return prebuiltPath;
+  }
+
+  // Fallback: check if already in build directory (from previous install)
+  const buildDir = path.join(__dirname, '..', 'build');
+  const buildPath = path.join(buildDir, 'Release', ADDON_NAME);
+
+  if (fs.existsSync(buildPath)) {
+    log('blue', 'Using existing build from previous installation');
+    return null; // Already in place, no need to copy
+  }
+
+  return null;
+}
+
+function getTargetPath() {
+  const targetDir = path.join(__dirname, '..', 'build', 'Release');
+  return path.join(targetDir, ADDON_NAME);
+}
+
+function ensureDirectoryExists(dirPath) {
+  if (!fs.existsSync(dirPath)) {
+    fs.mkdirSync(dirPath, { recursive: true });
+  }
+}
+
+function copyPrebuiltBinary() {
+  const prebuiltPath = getPrebuiltPath();
+  if (!prebuiltPath) {
+    log('warn', 'No prebuilt binary available for this platform');
+    return false;
+  }
+
+  const targetPath = getTargetPath();
+  const targetDir = path.dirname(targetPath);
+
+  try {
+    // Ensure target directory exists
+    ensureDirectoryExists(targetDir);
+
+    // Copy prebuilt binary
+    fs.copyFileSync(prebuiltPath, targetPath);
+
+    // Set executable permissions
+    fs.chmodSync(targetPath, 0o755);
+
+    log('green', `Installed prebuilt binary: ${targetPath}`);
+    return true;
+  } catch (error) {
+    log('red', `Failed to copy prebuilt binary: ${error.message}`);
+    return false;
+  }
+}
+
+function tryNativeBuild() {
+  const { execSync } = require('child_process');
+
+  try {
+    log('blue', 'Attempting native build...');
+
+    // Check if we have build tools
+    execSync('node-gyp --version', { stdio: 'pipe' });
+
+    // Try to build
+    execSync('node-gyp rebuild', {
+      stdio: 'inherit',
+      cwd: path.join(__dirname, '..')
+    });
+
+    // Verify build output
+    const targetPath = getTargetPath();
+    if (fs.existsSync(targetPath)) {
+      log('green', 'Native build successful');
+      return true;
+    } else {
+      log('red', 'Native build completed but addon not found');
+      return false;
+    }
+  } catch (error) {
+    log('yellow', `Native build failed: ${error.message}`);
+    return false;
+  }
+}
+
+function createFallbackMarker() {
+  const markerPath = path.join(__dirname, '..', '.fallback-mode');
+  try {
+    fs.writeFileSync(markerPath, JSON.stringify({
+      reason: 'No native addon available',
+      platform: os.platform(),
+      arch: os.arch(),
+      timestamp: new Date().toISOString()
+    }, null, 2));
+    log('yellow', 'Created fallback mode marker');
+  } catch (error) {
+    log('red', `Failed to create fallback marker: ${error.message}`);
+  }
+}
+
+function main() {
+  log('blue', `Installing ${PACKAGE_NAME}...`);
+  log('blue', `Platform: ${os.platform()}-${os.arch()}`);
+
+  // Skip installation in CI environments unless explicitly requested
+  if (process.env.CI && !process.env.FORCE_NATIVE_BUILD) {
+    log('yellow', 'Skipping native addon installation in CI environment');
+    createFallbackMarker();
+    return;
+  }
+
+  // Skip installation during npm pack/publish
+  if (process.env.npm_lifecycle_event === 'prepack' ||
+    process.env.npm_lifecycle_event === 'prepublishOnly') {
+    log('yellow', 'Skipping native addon installation during packaging');
+    return;
+  }
+
+  // Try prebuilt binary first
+  if (copyPrebuiltBinary()) {
+    log('green', 'Installation completed using prebuilt binary');
+    return;
+  }
+
+  // Fall back to native build
+  if (tryNativeBuild()) {
+    log('green', 'Installation completed using native build');
+    return;
+  }
+
+  // Create fallback marker
+  createFallbackMarker();
+  log('yellow', 'Installation completed in fallback mode (JavaScript only)');
+  log('yellow', 'Native licensing validation will not be available');
+}
+
+// Only run if called directly
+if (require.main === module) {
+  main();
+}

package/scripts/postinstall.js

@@ -0,0 +1,163 @@
+#!/usr/bin/env node
+/**
+ * Elastic License 2.0
+ *
+ * Copyright (c) 2024 Lambda Kata Team, Raman Marozau raman@worktif.com
+ *
+ * npm postinstall script for native licensing validator
+ * Verifies installation and provides user feedback
+ *
+ * @remarks Validates: Requirements 5.6
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+// Configuration
+const ADDON_NAME = 'lambda_kata_licensing.node';
+
+// Colors for output
+const colors = {
+  red: '\x1b[31m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+  reset: '\x1b[0m'
+};
+
+function log(level, message) {
+  const color = colors[level] || colors.reset;
+  console.log(`${color}[${level.toUpperCase()}]${colors.reset} ${message}`);
+}
+
+function checkNativeAddon() {
+  const addonPath = path.join(__dirname, '..', 'build', 'Release', ADDON_NAME);
+
+  if (!fs.existsSync(addonPath)) {
+    return {available: false, reason: 'Addon file not found'};
+  }
+
+  try {
+    const stats = fs.statSync(addonPath);
+
+    // Check if file is executable
+    const isExecutable = (stats.mode & parseInt('111', 8)) !== 0;
+    if (!isExecutable) {
+      return {available: false, reason: 'Addon file not executable'};
+    }
+
+    // Try to load the addon
+    const addon = require(addonPath);
+    if (typeof addon.checkEntitlement === 'function') {
+      return {available: true, path: addonPath, size: stats.size};
+    } else {
+      return {available: false, reason: 'Addon missing required exports'};
+    }
+  } catch (error) {
+    return {available: false, reason: `Addon load failed: ${error.message}`};
+  }
+}
+
+function checkFallbackMode() {
+  const markerPath = path.join(__dirname, '..', '.fallback-mode');
+
+  if (fs.existsSync(markerPath)) {
+    try {
+      const marker = JSON.parse(fs.readFileSync(markerPath, 'utf8'));
+      return {fallback: true, marker};
+    } catch (error) {
+      return {fallback: true, marker: {reason: 'Unknown'}};
+    }
+  }
+
+  return {fallback: false};
+}
+
+function checkTypeScriptOutput() {
+  const jsPath = path.join(__dirname, '..', 'out', 'dist', 'index.js');
+  const dtsPath = path.join(__dirname, '..', 'out', 'tsc', 'index.d.ts');
+
+  return {
+    js: fs.existsSync(jsPath),
+    types: fs.existsSync(dtsPath)
+  };
+}
+
+function displayInstallationSummary() {
+  log('blue', '='.repeat(60));
+  log('blue', 'Native Licensing Validator - Installation Summary');
+  log('blue', '='.repeat(60));
+
+  // Platform info
+  log('blue', `Platform: ${os.platform()}-${os.arch()}`);
+  log('blue', `Node.js: ${process.version}`);
+
+  // Check native addon
+  const addonStatus = checkNativeAddon();
+  if (addonStatus.available) {
+    log('green', `✓ Native addon: Available (${Math.round(addonStatus.size / 1024)}KB)`);
+    log('green', '  Enhanced security features enabled');
+  } else {
+    log('yellow', `⚠ Native addon: Not available (${addonStatus.reason})`);
+  }
+
+  // Check fallback mode
+  const fallbackStatus = checkFallbackMode();
+  if (fallbackStatus.fallback) {
+    log('yellow', `⚠ Fallback mode: Active (${fallbackStatus.marker.reason})`);
+    log('yellow', '  Using JavaScript-only implementation');
+  }
+
+  // Check TypeScript output
+  const tsStatus = checkTypeScriptOutput();
+  if (tsStatus.js && tsStatus.types) {
+    log('green', '✓ TypeScript output: Available');
+  } else {
+    log('red', '✗ TypeScript output: Missing');
+    if (!tsStatus.js) log('red', '  - JavaScript bundle missing');
+    if (!tsStatus.types) log('red', '  - Type definitions missing');
+  }
+
+  // Usage recommendations
+  log('blue', '');
+  log('blue', 'Usage:');
+  log('blue', '  const { NativeLicensingService } = require("@lambda-kata/licensing");');
+  log('blue', '  const service = new NativeLicensingService();');
+
+  if (!addonStatus.available) {
+    log('yellow', '');
+    log('yellow', 'Note: Native addon not available. The service will use fallback mode.');
+    log('yellow', 'For production use, ensure native addon is built for your target platform.');
+  }
+
+  // Lambda deployment info
+  if (addonStatus.available) {
+    log('blue', '');
+    log('blue', 'Lambda Deployment:');
+    log('blue', '  Use the provided Lambda Layer packages for deployment');
+    log('blue', '  Run: npm run build:all to create deployment artifacts');
+  }
+
+  log('blue', '='.repeat(60));
+}
+
+function main() {
+  // Skip in CI unless explicitly requested
+  if (process.env.CI && !process.env.SHOW_INSTALL_SUMMARY) {
+    return;
+  }
+
+  // Skip during npm pack/publish
+  if (process.env.npm_lifecycle_event === 'prepack' ||
+    process.env.npm_lifecycle_event === 'prepublishOnly') {
+    return;
+  }
+
+  displayInstallationSummary();
+}
+
+// Only run if called directly
+if (require.main === module) {
+  main();
+}