diffx-js 0.5.1 → 0.5.3

package/README.md

@@ -8,7 +8,18 @@ A Node.js wrapper for the `diffx` CLI tool.
 npm install diffx-js
 ```
 
-This will automatically download the appropriate `diffx` binary for your system from GitHub Releases.
+This package includes pre-compiled `diffx` binaries for all supported platforms (Linux x64, macOS x64/ARM64, Windows x64), enabling **completely offline installation** with no external downloads required.
+
+### Supported Platforms
+
+- **Linux x64** - Intel/AMD 64-bit
+- **macOS x64** - Intel-based Macs
+- **macOS ARM64** - Apple Silicon Macs (M1/M2/M3)
+- **Windows x64** - 64-bit Windows
+
+The appropriate binary is automatically selected at runtime based on your system.
+
+**Note:** Due to bundling all platform binaries, this package is larger (~20MB) than typical npm packages but provides complete offline functionality.
 
 ## Usage
 

package/index.js

@@ -4,21 +4,37 @@ const { spawn } = require('child_process');
 const path = require('path');
 const fs = require('fs');
 
-// Determine the platform-specific binary name
-let binaryName = 'diffx';
-if (process.platform === 'win32') {
-  binaryName = 'diffx.exe';
+// Determine the platform-specific binary name and directory
+function getPlatformInfo() {
+  const platform = process.platform;
+  const arch = process.arch;
+  
+  if (platform === 'win32') {
+    return { subdir: 'win32-x64', binaryName: 'diffx.exe' };
+  } else if (platform === 'darwin') {
+    if (arch === 'arm64') {
+      return { subdir: 'darwin-arm64', binaryName: 'diffx' };
+    } else {
+      return { subdir: 'darwin-x64', binaryName: 'diffx' };
+    }
+  } else if (platform === 'linux') {
+    return { subdir: 'linux-x64', binaryName: 'diffx' };
+  } else {
+    throw new Error(`Unsupported platform: ${platform}-${arch}`);
+  }
 }
 
-// Construct the path to the binary
-// In a real scenario, this would involve downloading the binary
-// For now, we assume it's in a 'bin' directory relative to this script
-const binaryPath = path.join(__dirname, 'bin', binaryName);
+// Get platform-specific binary path
+const platformInfo = getPlatformInfo();
+const binaryPath = path.join(__dirname, 'bin', platformInfo.subdir, platformInfo.binaryName);
 
 // Check if the binary exists
 if (!fs.existsSync(binaryPath)) {
   console.error(`Error: Binary not found at ${binaryPath}`);
-  console.error('Please ensure diffx is properly installed or built for your platform.');
+  console.error(`Platform: ${process.platform}-${process.arch}`);
+  console.error('Expected platform-specific binary not found.');
+  console.error('This might indicate a packaging issue. Please report this at:');
+  console.error('https://github.com/kako-jun/diffx/issues');
   process.exit(1);
 }
 

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "diffx-js",
-  "version": "0.5.1",
+  "version": "0.5.3",
   "description": "A Node.js wrapper for the diffx CLI tool - semantic diffing of JSON, YAML, TOML, XML, INI, and CSV files. Focuses on structural meaning rather than formatting.",
   "keywords": [
     "diff",
-    "json", 
+    "json",
     "yaml",
     "toml",
     "xml",
@@ -25,11 +25,11 @@
     "diffx": "./index.js"
   },
   "scripts": {
-    "postinstall": "node scripts/download-binary.js",
     "test": "node test.js",
     "examples": "node examples.js",
     "verify": "node index.js --help",
-    "prepublish": "npm run verify"
+    "prepublish": "npm run verify",
+    "download-binaries": "node scripts/download-all-binaries.js"
   },
   "engines": {
     "node": ">=12.0.0"
@@ -38,13 +38,21 @@
     "index.js",
     "lib.js",
     "scripts/download-binary.js",
+    "scripts/download-all-binaries.js",
     "bin/",
     "README.md",
     "examples.js",
     "test.js"
   ],
-  "os": ["linux", "darwin", "win32"],
-  "cpu": ["x64", "arm64"],
+  "os": [
+    "linux",
+    "darwin",
+    "win32"
+  ],
+  "cpu": [
+    "x64",
+    "arm64"
+  ],
   "author": "kako-jun",
   "license": "MIT",
   "homepage": "https://github.com/kako-jun/diffx",

package/scripts/download-all-binaries.js

@@ -0,0 +1,166 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+const https = require('https');
+const { execSync } = require('child_process');
+
+const DIFFX_VERSION = require('../package.json').version;
+const BINARY_DIR = path.join(__dirname, '..', 'bin');
+
+// All platform configurations
+const PLATFORMS = [
+  { 
+    name: 'linux-x64', 
+    file: 'diffx-linux-x86_64.tar.gz',
+    binaryName: 'diffx',
+    subdir: 'linux-x64'
+  },
+  { 
+    name: 'darwin-x64', 
+    file: 'diffx-macos-x86_64.tar.gz',
+    binaryName: 'diffx',
+    subdir: 'darwin-x64'
+  },
+  { 
+    name: 'darwin-arm64', 
+    file: 'diffx-macos-aarch64.tar.gz',
+    binaryName: 'diffx',
+    subdir: 'darwin-arm64'
+  },
+  { 
+    name: 'win32-x64', 
+    file: 'diffx-windows-x86_64.zip',
+    binaryName: 'diffx.exe',
+    subdir: 'win32-x64'
+  }
+];
+
+function downloadFile(url, dest) {
+  return new Promise((resolve, reject) => {
+    console.log(`Downloading ${path.basename(dest)}...`);
+    const file = fs.createWriteStream(dest);
+    
+    https.get(url, (response) => {
+      if (response.statusCode === 302 || response.statusCode === 301) {
+        // Follow redirect
+        downloadFile(response.headers.location, dest).then(resolve).catch(reject);
+        return;
+      }
+      
+      if (response.statusCode !== 200) {
+        reject(new Error(`HTTP ${response.statusCode}: ${response.statusMessage}`));
+        return;
+      }
+      
+      response.pipe(file);
+      
+      file.on('finish', () => {
+        file.close();
+        resolve();
+      });
+      
+      file.on('error', (err) => {
+        fs.unlink(dest, () => {}); // Delete the file async
+        reject(err);
+      });
+    }).on('error', (err) => {
+      reject(err);
+    });
+  });
+}
+
+async function extractArchive(archivePath, extractDir) {
+  if (archivePath.endsWith('.zip')) {
+    // Use Node.js built-in for cross-platform ZIP extraction
+    const { execSync } = require('child_process');
+    try {
+      // Try with PowerShell on Windows
+      if (process.platform === 'win32') {
+        execSync(`powershell -command "Expand-Archive -Path '${archivePath}' -DestinationPath '${extractDir}' -Force"`, { stdio: 'inherit' });
+      } else {
+        // For Linux/macOS, use Python's zipfile module (more widely available than unzip)
+        execSync(`python3 -c "import zipfile; zipfile.ZipFile('${archivePath}').extractall('${extractDir}')"`, { stdio: 'inherit' });
+      }
+    } catch (error) {
+      // Fallback to manual extraction using Node.js modules
+      const AdmZip = require('adm-zip');
+      const zip = new AdmZip(archivePath);
+      zip.extractAllTo(extractDir, true);
+    }
+  } else if (archivePath.endsWith('.tar.gz')) {
+    execSync(`tar -xzf "${archivePath}" -C "${extractDir}"`, { stdio: 'inherit' });
+  }
+}
+
+async function downloadPlatformBinary(platform) {
+  const downloadUrl = `https://github.com/kako-jun/diffx/releases/download/v${DIFFX_VERSION}/${platform.file}`;
+  const platformDir = path.join(BINARY_DIR, platform.subdir);
+  const archivePath = path.join(platformDir, platform.file);
+  
+  // Create platform-specific directory
+  if (!fs.existsSync(platformDir)) {
+    fs.mkdirSync(platformDir, { recursive: true });
+  }
+  
+  // Check if binary already exists
+  const binaryPath = path.join(platformDir, platform.binaryName);
+  if (fs.existsSync(binaryPath)) {
+    console.log(`Binary for ${platform.name} already exists, skipping download.`);
+    return;
+  }
+  
+  try {
+    // Download archive
+    await downloadFile(downloadUrl, archivePath);
+    
+    // Extract binary
+    console.log(`Extracting ${platform.name} binary...`);
+    await extractArchive(archivePath, platformDir);
+    
+    // Clean up archive
+    fs.unlinkSync(archivePath);
+    
+    // Make binary executable on Unix systems
+    if (platform.binaryName !== 'diffx.exe') {
+      fs.chmodSync(binaryPath, '755');
+    }
+    
+    console.log(`SUCCESS: ${platform.name} binary installed at ${binaryPath}`);
+    
+  } catch (error) {
+    console.error(`ERROR: Failed to download ${platform.name} binary:`, error.message);
+    throw error;
+  }
+}
+
+async function main() {
+  try {
+    console.log(`Downloading diffx v${DIFFX_VERSION} binaries for all platforms...`);
+    
+    // Create main bin directory
+    if (!fs.existsSync(BINARY_DIR)) {
+      fs.mkdirSync(BINARY_DIR, { recursive: true });
+    }
+    
+    // Download all platform binaries
+    for (const platform of PLATFORMS) {
+      await downloadPlatformBinary(platform);
+    }
+    
+    console.log('\n🎉 All platform binaries downloaded successfully!');
+    console.log('\nBinary structure:');
+    console.log('bin/');
+    for (const platform of PLATFORMS) {
+      console.log(`  └── ${platform.subdir}/${platform.binaryName}`);
+    }
+    
+  } catch (error) {
+    console.error('ERROR: Failed to download platform binaries:', error.message);
+    process.exit(1);
+  }
+}
+
+if (require.main === module) {
+  main();
+}

package/test.js

@@ -118,12 +118,12 @@ async function runTests() {
             'test2.json'
         ]);
         
-        if (diffResult.code === 0 && 
+        if (diffResult.code === 1 && 
             diffResult.stdout.includes('version') && 
             diffResult.stdout.includes('debug')) {
             success('Basic JSON diff works correctly');
         } else {
-            error(`JSON diff failed: ${diffResult.stderr}`);
+            error(`JSON diff failed. Code: ${diffResult.code}, Stdout: ${diffResult.stdout}, Stderr: ${diffResult.stderr}`);
             throw new Error('JSON diff failed');
         }
 
@@ -137,7 +137,7 @@ async function runTests() {
             'json'
         ]);
 
-        if (jsonOutputResult.code === 0) {
+        if (jsonOutputResult.code === 1) {
             try {
                 const output = JSON.parse(jsonOutputResult.stdout);
                 if (Array.isArray(output) && output.length > 0) {
@@ -166,7 +166,7 @@ async function runTests() {
             'test2.yaml'
         ]);
         
-        if (yamlResult.code === 0 && yamlResult.stdout.includes('version')) {
+        if (yamlResult.code === 1 && yamlResult.stdout.includes('version')) {
             success('YAML diff works correctly');
         } else {
             error(`YAML diff failed: ${yamlResult.stderr}`);
@@ -220,8 +220,34 @@ async function runTests() {
             throw new Error('Error handling failed');
         }
 
-        // Test 8: API functionality with new options
-        info('Test 8: Testing API functionality with new options...');
+        // Test 8: Platform-specific binary verification
+        info('Test 8: Testing platform-specific binary verification...');
+        
+        const platform = process.platform;
+        const arch = process.arch;
+        let expectedBinaryPath;
+        
+        if (platform === 'win32') {
+            expectedBinaryPath = path.join(__dirname, 'bin', 'win32-x64', 'diffx.exe');
+        } else if (platform === 'darwin') {
+            if (arch === 'arm64') {
+                expectedBinaryPath = path.join(__dirname, 'bin', 'darwin-arm64', 'diffx');
+            } else {
+                expectedBinaryPath = path.join(__dirname, 'bin', 'darwin-x64', 'diffx');
+            }
+        } else if (platform === 'linux') {
+            expectedBinaryPath = path.join(__dirname, 'bin', 'linux-x64', 'diffx');
+        }
+        
+        if (fs.existsSync(expectedBinaryPath)) {
+            success(`Platform-specific binary found: ${expectedBinaryPath}`);
+        } else {
+            error(`Platform-specific binary not found: ${expectedBinaryPath}`);
+            throw new Error('Platform binary missing');
+        }
+
+        // Test 9: API functionality with new options
+        info('Test 9: Testing API functionality with new options...');
         
         // Test ignore case option
         try {