node-version-use 1.9.9 → 2.0.0

package/scripts/postinstall.cjs

@@ -0,0 +1,273 @@
+/**
+ * Postinstall script for node-version-use
+ *
+ * Downloads the platform-specific shim binary and installs it to ~/.nvu/bin/
+ * This enables transparent Node version switching via the shim.
+ *
+ * Compatible with Node.js 0.8+
+ */
+
+var fs = require('fs');
+var path = require('path');
+var os = require('os');
+var exit = require('exit');
+var getRemote = require('get-remote');
+
+// Polyfills for old Node versions
+var mkdirp = require('mkdirp-classic');
+var homedir = typeof os.homedir === 'function' ? os.homedir() : require('homedir-polyfill')();
+
+// execSync doesn't exist in Node 0.8, use spawn
+var spawn = require('child_process').spawn;
+
+// Configuration
+var GITHUB_REPO = 'kmalakoff/node-version-use';
+var SHIM_VERSION = '1.0.2';
+
+/**
+ * Get the platform-specific binary name
+ */
+function getShimBinaryName() {
+  var platform = os.platform();
+  var arch = os.arch();
+
+  var platformMap = {
+    darwin: 'darwin',
+    linux: 'linux',
+    win32: 'win32',
+  };
+
+  var archMap = {
+    x64: 'x64',
+    arm64: 'arm64',
+    amd64: 'x64',
+  };
+
+  var platformName = platformMap[platform];
+  var archName = archMap[arch];
+
+  if (!platformName || !archName) {
+    return null;
+  }
+
+  var ext = platform === 'win32' ? '.exe' : '';
+  return 'nvu-shim-' + platformName + '-' + archName + ext;
+}
+
+/**
+ * Get the download URL for the shim binary
+ */
+function getDownloadUrl(binaryName) {
+  var ext = os.platform() === 'win32' ? '.zip' : '.tar.gz';
+  return 'https://github.com/' + GITHUB_REPO + '/releases/download/shim-v' + SHIM_VERSION + '/' + binaryName + ext;
+}
+
+/**
+ * Copy file (compatible with Node 0.8)
+ */
+function copyFileSync(src, dest) {
+  var content = fs.readFileSync(src);
+  fs.writeFileSync(dest, content);
+}
+
+/**
+ * Download a file from a URL (using get-remote for Node 0.8+ compatibility)
+ */
+function downloadFile(url, destPath, callback) {
+  var writeStream = fs.createWriteStream(destPath);
+  getRemote(url).pipe(writeStream, callback);
+}
+
+/**
+ * Extract archive and install shims (callback-based)
+ */
+function extractAndInstall(archivePath, destDir, binaryName, callback) {
+  var platform = os.platform();
+
+  if (platform === 'win32') {
+    // Windows: extract zip using PowerShell
+    var ps = spawn('powershell', ['-Command', "Expand-Archive -Path '" + archivePath + "' -DestinationPath '" + destDir + "' -Force"]);
+    ps.on('close', function (code) {
+      if (code !== 0) {
+        callback(new Error('Failed to extract archive'));
+        return;
+      }
+      var extractedPath = path.join(destDir, binaryName);
+      if (fs.existsSync(extractedPath)) {
+        try {
+          copyFileSync(extractedPath, path.join(destDir, 'node.exe'));
+          copyFileSync(extractedPath, path.join(destDir, 'npm.exe'));
+          copyFileSync(extractedPath, path.join(destDir, 'npx.exe'));
+          fs.unlinkSync(extractedPath);
+        } catch (err) {
+          callback(err);
+          return;
+        }
+      }
+      callback(null);
+    });
+  } else {
+    // Unix: extract tar.gz
+    var tar = spawn('tar', ['-xzf', archivePath, '-C', destDir]);
+    tar.on('close', function (code) {
+      if (code !== 0) {
+        callback(new Error('Failed to extract archive'));
+        return;
+      }
+      var extractedPath = path.join(destDir, binaryName);
+      if (fs.existsSync(extractedPath)) {
+        var nodePath = path.join(destDir, 'node');
+        var npmPath = path.join(destDir, 'npm');
+        var npxPath = path.join(destDir, 'npx');
+
+        try {
+          copyFileSync(extractedPath, nodePath);
+          copyFileSync(extractedPath, npmPath);
+          copyFileSync(extractedPath, npxPath);
+
+          fs.chmodSync(nodePath, 493); // 0755
+          fs.chmodSync(npmPath, 493);
+          fs.chmodSync(npxPath, 493);
+
+          fs.unlinkSync(extractedPath);
+        } catch (err) {
+          callback(err);
+          return;
+        }
+      }
+      callback(null);
+    });
+  }
+}
+
+/**
+ * Print setup instructions
+ */
+function printInstructions(installed) {
+  var nvuBinPath = path.join(homedir, '.nvu', 'bin');
+  var platform = os.platform();
+
+  console.log('');
+  console.log('============================================================');
+  if (installed) {
+    console.log('  nvu shims installed to ~/.nvu/bin/');
+  } else {
+    console.log('  nvu installed (shims not yet available)');
+  }
+  console.log('============================================================');
+  console.log('');
+  console.log('To enable transparent Node version switching, add to your shell profile:');
+  console.log('');
+
+  if (platform === 'win32') {
+    console.log('  PowerShell (add to $PROFILE):');
+    console.log('    $env:PATH = "' + nvuBinPath + ';$env:PATH"');
+    console.log('');
+    console.log('  CMD (run as administrator):');
+    console.log('    setx PATH "' + nvuBinPath + ';%PATH%"');
+  } else {
+    console.log('  # For bash (~/.bashrc):');
+    console.log('    export PATH="$HOME/.nvu/bin:$PATH"');
+    console.log('');
+    console.log('  # For zsh (~/.zshrc):');
+    console.log('    export PATH="$HOME/.nvu/bin:$PATH"');
+    console.log('');
+    console.log('  # For fish (~/.config/fish/config.fish):');
+    console.log('    set -gx PATH $HOME/.nvu/bin $PATH');
+  }
+
+  console.log('');
+  console.log('Then restart your terminal or source your shell profile.');
+  console.log('');
+  console.log("Without this, 'nvu 18 npm test' still works - you just won't have");
+  console.log("transparent 'node' command override.");
+  console.log('============================================================');
+}
+
+/**
+ * Get temp directory (compatible with Node 0.8)
+ */
+function getTmpDir() {
+  return typeof os.tmpdir === 'function' ? os.tmpdir() : process.env.TMPDIR || process.env.TMP || process.env.TEMP || '/tmp';
+}
+
+/**
+ * Main installation function
+ */
+function main() {
+  var binaryName = getShimBinaryName();
+
+  if (!binaryName) {
+    console.log('postinstall: Unsupported platform/architecture for shim binary.');
+    console.log('Platform: ' + os.platform() + ', Arch: ' + os.arch());
+    console.log('Shim not installed. You can still use nvu with explicit versions: nvu 18 npm test');
+    exit(0);
+    return;
+  }
+
+  var nvuDir = path.join(homedir, '.nvu');
+  var binDir = path.join(nvuDir, 'bin');
+
+  // Create directories
+  mkdirp.sync(nvuDir);
+  mkdirp.sync(binDir);
+
+  var downloadUrl = getDownloadUrl(binaryName);
+  var ext = os.platform() === 'win32' ? '.zip' : '.tar.gz';
+  var tempPath = path.join(getTmpDir(), 'nvu-shim-' + Date.now() + ext);
+
+  console.log('postinstall: Downloading shim binary for ' + os.platform() + '-' + os.arch() + '...');
+
+  downloadFile(downloadUrl, tempPath, function (downloadErr) {
+    if (downloadErr) {
+      // Clean up temp file if it exists
+      if (fs.existsSync(tempPath)) {
+        try {
+          fs.unlinkSync(tempPath);
+        } catch (_e) {}
+      }
+
+      if (downloadErr.message && downloadErr.message.indexOf('404') >= 0) {
+        console.log('postinstall: Shim binaries not yet published to GitHub releases.');
+        console.log('');
+        console.log('To build and install shims locally:');
+        console.log('  cd node_modules/node-version-use/shim');
+        console.log('  make install');
+        console.log('');
+        console.log('Or wait for the next release which will include pre-built binaries.');
+      } else {
+        console.log('postinstall warning: Failed to install shim: ' + (downloadErr.message || downloadErr));
+        console.log('You can still use nvu with explicit versions: nvu 18 npm test');
+        console.log('To install shims manually: cd node_modules/node-version-use/shim && make install');
+      }
+      printInstructions(false);
+      exit(0);
+      return;
+    }
+
+    console.log('postinstall: Extracting shim binary...');
+
+    extractAndInstall(tempPath, binDir, binaryName, function (extractErr) {
+      // Clean up temp file
+      if (fs.existsSync(tempPath)) {
+        try {
+          fs.unlinkSync(tempPath);
+        } catch (_e) {}
+      }
+
+      if (extractErr) {
+        console.log('postinstall warning: Failed to extract shim: ' + (extractErr.message || extractErr));
+        console.log('You can still use nvu with explicit versions: nvu 18 npm test');
+        printInstructions(false);
+        exit(0);
+        return;
+      }
+
+      console.log('postinstall: Shim installed successfully!');
+      printInstructions(true);
+      exit(0);
+    });
+  });
+}
+
+main();

package/shim/Makefile

@@ -0,0 +1,58 @@
+# Makefile for building nvu shim binaries for all platforms
+
+VERSION ?= $(shell git describe --tags --always --dirty 2>/dev/null || echo "dev")
+BUILD_DIR := build
+BINARY_NAME := nvu-shim
+
+# Build flags for smaller binaries
+LDFLAGS := -s -w -X main.version=$(VERSION)
+
+.PHONY: all clean darwin-arm64 darwin-x64 linux-x64 linux-arm64 windows-x64 windows-arm64 local install release
+
+all: darwin-arm64 darwin-x64 linux-x64 linux-arm64 windows-x64 windows-arm64
+
+$(BUILD_DIR):
+	mkdir -p $(BUILD_DIR)
+
+darwin-arm64: $(BUILD_DIR)
+	GOOS=darwin GOARCH=arm64 go build -ldflags="$(LDFLAGS)" -o $(BUILD_DIR)/$(BINARY_NAME)-darwin-arm64 .
+
+darwin-x64: $(BUILD_DIR)
+	GOOS=darwin GOARCH=amd64 go build -ldflags="$(LDFLAGS)" -o $(BUILD_DIR)/$(BINARY_NAME)-darwin-x64 .
+
+linux-x64: $(BUILD_DIR)
+	GOOS=linux GOARCH=amd64 go build -ldflags="$(LDFLAGS)" -o $(BUILD_DIR)/$(BINARY_NAME)-linux-x64 .
+
+linux-arm64: $(BUILD_DIR)
+	GOOS=linux GOARCH=arm64 go build -ldflags="$(LDFLAGS)" -o $(BUILD_DIR)/$(BINARY_NAME)-linux-arm64 .
+
+windows-x64: $(BUILD_DIR)
+	GOOS=windows GOARCH=amd64 go build -ldflags="$(LDFLAGS)" -o $(BUILD_DIR)/$(BINARY_NAME)-win32-x64.exe .
+
+windows-arm64: $(BUILD_DIR)
+	GOOS=windows GOARCH=arm64 go build -ldflags="$(LDFLAGS)" -o $(BUILD_DIR)/$(BINARY_NAME)-win32-arm64.exe .
+
+# Build for current platform (for local testing)
+local: $(BUILD_DIR)
+	go build -ldflags="$(LDFLAGS)" -o $(BUILD_DIR)/$(BINARY_NAME) .
+
+# Install shims to ~/.nvu/bin for local testing
+install: local
+	mkdir -p $(HOME)/.nvu/bin
+	cp $(BUILD_DIR)/$(BINARY_NAME) $(HOME)/.nvu/bin/node
+	cp $(BUILD_DIR)/$(BINARY_NAME) $(HOME)/.nvu/bin/npm
+	cp $(BUILD_DIR)/$(BINARY_NAME) $(HOME)/.nvu/bin/npx
+	@echo "Shims installed to ~/.nvu/bin/"
+	@echo "Add to your PATH: export PATH=\"\$$HOME/.nvu/bin:\$$PATH\""
+
+clean:
+	rm -rf $(BUILD_DIR)
+
+# Create release archives
+release: all
+	cd $(BUILD_DIR) && tar -czf $(BINARY_NAME)-darwin-arm64.tar.gz $(BINARY_NAME)-darwin-arm64
+	cd $(BUILD_DIR) && tar -czf $(BINARY_NAME)-darwin-x64.tar.gz $(BINARY_NAME)-darwin-x64
+	cd $(BUILD_DIR) && tar -czf $(BINARY_NAME)-linux-x64.tar.gz $(BINARY_NAME)-linux-x64
+	cd $(BUILD_DIR) && tar -czf $(BINARY_NAME)-linux-arm64.tar.gz $(BINARY_NAME)-linux-arm64
+	cd $(BUILD_DIR) && zip $(BINARY_NAME)-win32-x64.zip $(BINARY_NAME)-win32-x64.exe
+	cd $(BUILD_DIR) && zip $(BINARY_NAME)-win32-arm64.zip $(BINARY_NAME)-win32-arm64.exe

package/shim/go.mod

@@ -0,0 +1,3 @@
+module github.com/kmalakoff/node-version-use/shim
+
+go 1.21

package/shim/main.go

@@ -0,0 +1,302 @@
+package main
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"syscall"
+)
+
+// Version resolution priority:
+// 1. .nvurc in current or parent directories
+// 2. .nvmrc in current or parent directories
+// 3. ~/.nvu/default (global default)
+
+func main() {
+	// Determine which binary we're shimming based on the executable name
+	execName := filepath.Base(os.Args[0])
+	// Remove .exe suffix on Windows
+	execName = strings.TrimSuffix(execName, ".exe")
+
+	// Check if we're running the nvu CLI itself - if so, use any available version
+	// This prevents chicken-and-egg problems where nvu can't run because the
+	// configured version isn't installed yet
+	isNvuCli := isRunningNvuCli()
+
+	var version string
+	var err error
+
+	if isNvuCli {
+		// For nvu CLI, use any available installed version
+		version, err = findAnyInstalledVersion()
+		if err != nil {
+			fmt.Fprintf(os.Stderr, "nvu shim error: no Node versions installed\n")
+			fmt.Fprintf(os.Stderr, "\nInstall Node manually first, or use system Node to run:\n")
+			fmt.Fprintf(os.Stderr, "  /usr/bin/node $(which nvu) install 20\n")
+			os.Exit(1)
+		}
+	} else {
+		// Resolve the Node version to use
+		version, err = resolveVersion()
+		if err != nil {
+			fmt.Fprintf(os.Stderr, "nvu shim error: %s\n", err)
+			fmt.Fprintf(os.Stderr, "\nTo fix this, either:\n")
+			fmt.Fprintf(os.Stderr, "  1. Create a .nvmrc file with a version: echo 20 > .nvmrc\n")
+			fmt.Fprintf(os.Stderr, "  2. Set a global default: nvu default 20\n")
+			os.Exit(1)
+		}
+	}
+
+	// Find the real binary path
+	binaryPath, err := findBinary(execName, version)
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "nvu shim error: %s\n", err)
+		fmt.Fprintf(os.Stderr, "\nNode %s may not be installed. Run: nvu install %s\n", version, version)
+		os.Exit(1)
+	}
+
+	// Execute the real binary, replacing this process
+	err = execBinary(binaryPath, os.Args)
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "nvu shim error: failed to exec %s: %s\n", binaryPath, err)
+		os.Exit(1)
+	}
+}
+
+// resolveVersion determines which Node version to use
+func resolveVersion() (string, error) {
+	// 1. Check for .nvurc or .nvmrc in current directory and parents
+	cwd, err := os.Getwd()
+	if err != nil {
+		return "", fmt.Errorf("failed to get current directory: %w", err)
+	}
+
+	version := findVersionInParents(cwd)
+	if version != "" {
+		return version, nil
+	}
+
+	// 2. Check global default
+	homeDir, err := os.UserHomeDir()
+	if err != nil {
+		return "", fmt.Errorf("failed to get home directory: %w", err)
+	}
+
+	defaultPath := filepath.Join(homeDir, ".nvu", "default")
+	version, err = readVersionFile(defaultPath)
+	if err == nil && version != "" {
+		return version, nil
+	}
+
+	return "", fmt.Errorf("no Node version configured")
+}
+
+// findVersionInParents walks up the directory tree looking for version config files
+func findVersionInParents(dir string) string {
+	for {
+		// Check .nvurc first (nvu-specific)
+		version, err := readVersionFile(filepath.Join(dir, ".nvurc"))
+		if err == nil && version != "" {
+			return version
+		}
+
+		// Check .nvmrc (ecosystem compatible)
+		version, err = readVersionFile(filepath.Join(dir, ".nvmrc"))
+		if err == nil && version != "" {
+			return version
+		}
+
+		// Move to parent directory
+		parent := filepath.Dir(dir)
+		if parent == dir {
+			// Reached root
+			break
+		}
+		dir = parent
+	}
+	return ""
+}
+
+// readVersionFile reads a version from a file, trimming whitespace
+func readVersionFile(path string) (string, error) {
+	content, err := os.ReadFile(path)
+	if err != nil {
+		return "", err
+	}
+	version := strings.TrimSpace(string(content))
+	return version, nil
+}
+
+// findBinary locates the actual binary for the given command and version
+func findBinary(name string, version string) (string, error) {
+	homeDir, err := os.UserHomeDir()
+	if err != nil {
+		return "", fmt.Errorf("failed to get home directory: %w", err)
+	}
+
+	versionsDir := filepath.Join(homeDir, ".nvu", "versions")
+
+	// Resolve version to an installed version directory
+	resolvedVersion, err := resolveInstalledVersion(versionsDir, version)
+	if err != nil {
+		return "", err
+	}
+
+	// The binary should be at ~/.nvu/versions/<version>/bin/<name>
+	var binaryPath string
+	if runtime.GOOS == "windows" {
+		// On Windows, look for .exe or .cmd
+		binaryPath = filepath.Join(versionsDir, resolvedVersion, "bin", name+".exe")
+		if _, err := os.Stat(binaryPath); os.IsNotExist(err) {
+			// Try without bin/ (for node.exe which might be at root)
+			binaryPath = filepath.Join(versionsDir, resolvedVersion, name+".exe")
+		}
+		if _, err := os.Stat(binaryPath); os.IsNotExist(err) {
+			// Try .cmd for npm/npx
+			binaryPath = filepath.Join(versionsDir, resolvedVersion, name+".cmd")
+		}
+	} else {
+		binaryPath = filepath.Join(versionsDir, resolvedVersion, "bin", name)
+	}
+
+	if _, err := os.Stat(binaryPath); os.IsNotExist(err) {
+		return "", fmt.Errorf("binary not found: %s", binaryPath)
+	}
+
+	return binaryPath, nil
+}
+
+// resolveInstalledVersion finds the best matching installed version
+func resolveInstalledVersion(versionsDir string, version string) (string, error) {
+	// Normalize version - remove 'v' prefix for comparison
+	normalizedVersion := strings.TrimPrefix(version, "v")
+
+	// Try exact matches first (with and without 'v' prefix)
+	exactMatches := []string{version, "v" + normalizedVersion, normalizedVersion}
+	for _, v := range exactMatches {
+		path := filepath.Join(versionsDir, v)
+		if info, err := os.Stat(path); err == nil && info.IsDir() {
+			return v, nil
+		}
+	}
+
+	// If no exact match, scan for partial version match (e.g., "20" matches "v20.19.6")
+	entries, err := os.ReadDir(versionsDir)
+	if err != nil {
+		return "", fmt.Errorf("failed to read versions directory: %w", err)
+	}
+
+	var bestMatch string
+	for _, entry := range entries {
+		if !entry.IsDir() {
+			continue
+		}
+		dirName := entry.Name()
+		dirVersion := strings.TrimPrefix(dirName, "v")
+
+		// Check if this version starts with our target
+		if strings.HasPrefix(dirVersion, normalizedVersion+".") || dirVersion == normalizedVersion {
+			// Prefer higher versions (simple string comparison works for semver)
+			if bestMatch == "" || dirName > bestMatch {
+				bestMatch = dirName
+			}
+		}
+	}
+
+	if bestMatch != "" {
+		return bestMatch, nil
+	}
+
+	return "", fmt.Errorf("no installed version matching %s", version)
+}
+
+// execBinary replaces the current process with the target binary
+func execBinary(binaryPath string, args []string) error {
+	// On Unix, use syscall.Exec to replace the process
+	// On Windows, we need to use exec.Command and wait
+	if runtime.GOOS == "windows" {
+		return execWindows(binaryPath, args)
+	}
+	return execUnix(binaryPath, args)
+}
+
+func execUnix(binaryPath string, args []string) error {
+	// Replace args[0] with the actual binary path
+	args[0] = binaryPath
+	return syscall.Exec(binaryPath, args, os.Environ())
+}
+
+func execWindows(binaryPath string, args []string) error {
+	// On Windows, we can't use syscall.Exec, so we spawn and wait
+	cmd := exec.Command(binaryPath, args[1:]...)
+	cmd.Stdin = os.Stdin
+	cmd.Stdout = os.Stdout
+	cmd.Stderr = os.Stderr
+	cmd.Env = os.Environ()
+
+	err := cmd.Run()
+	if err != nil {
+		if exitError, ok := err.(*exec.ExitError); ok {
+			os.Exit(exitError.ExitCode())
+		}
+		return err
+	}
+	os.Exit(0)
+	return nil
+}
+
+// isRunningNvuCli checks if we're being used to run the nvu CLI
+func isRunningNvuCli() bool {
+	if len(os.Args) < 2 {
+		return false
+	}
+
+	// Check if the script being run is the nvu CLI
+	script := os.Args[1]
+
+	// Check for common nvu CLI paths
+	if strings.Contains(script, "node-version-use") {
+		return true
+	}
+	if strings.HasSuffix(script, "/nvu") || strings.HasSuffix(script, "\\nvu") {
+		return true
+	}
+	if filepath.Base(script) == "nvu" || filepath.Base(script) == "nvu.js" {
+		return true
+	}
+
+	return false
+}
+
+// findAnyInstalledVersion returns any installed Node version
+func findAnyInstalledVersion() (string, error) {
+	homeDir, err := os.UserHomeDir()
+	if err != nil {
+		return "", err
+	}
+
+	versionsDir := filepath.Join(homeDir, ".nvu", "versions")
+	entries, err := os.ReadDir(versionsDir)
+	if err != nil {
+		return "", err
+	}
+
+	// Return the first installed version we find
+	for _, entry := range entries {
+		if entry.IsDir() {
+			// Verify it has a node binary
+			nodePath := filepath.Join(versionsDir, entry.Name(), "bin", "node")
+			if runtime.GOOS == "windows" {
+				nodePath = filepath.Join(versionsDir, entry.Name(), "node.exe")
+			}
+			if _, err := os.Stat(nodePath); err == nil {
+				return entry.Name(), nil
+			}
+		}
+	}
+
+	return "", fmt.Errorf("no installed versions found")
+}