symfluence 0.5.8

package/README.md

@@ -0,0 +1,205 @@
+# SYMFLUENCE - npm Package
+
+Pre-compiled hydrological modeling tools for SYMFLUENCE framework.
+
+## What's Included
+
+This package provides pre-built binaries for:
+
+- **SUMMA** - Structure for Unifying Multiple Modeling Alternatives
+- **mizuRoute** - Multi-scale routing model
+- **FUSE** - Framework for Understanding Structural Errors
+- **NGEN** - NOAA Next Generation Water Resources Modeling Framework
+- **TauDEM** - Terrain Analysis Using Digital Elevation Models
+
+## Installation
+
+### Global Installation (Recommended)
+
+```bash
+npm install -g symfluence
+```
+
+This will:
+1. Download platform-specific pre-compiled binaries (~50-100 MB)
+2. Extract them to your global npm directory
+3. Make the `symfluence` command available
+
+### Local Installation
+
+```bash
+npm install symfluence
+```
+
+## Supported Platforms
+
+- **Linux**: x86_64 (Ubuntu 22.04+, RHEL 9+, Debian 12+)
+- **macOS**: ARM64 (Apple Silicon M1/M2/M3, macOS 12+)
+
+## System Requirements
+
+### Linux
+
+- **OS**: Ubuntu 22.04+, RHEL 9+, or Debian 12+
+- **glibc**: ≥ 2.35
+- **Libraries** (must be installed):
+  ```bash
+  sudo apt-get install libnetcdf19 libnetcdff7 libhdf5-103 libgdal32
+  ```
+
+### macOS
+
+- **OS**: macOS 12 (Monterey) or later
+- **Architecture**: Apple Silicon (ARM64)
+- **Libraries** (install via Homebrew):
+  ```bash
+  brew install netcdf netcdf-fortran hdf5 gdal
+  ```
+
+For detailed requirements, see [SYSTEM_REQUIREMENTS.md](https://github.com/DarriEy/SYMFLUENCE/blob/main/docs/SYSTEM_REQUIREMENTS.md).
+
+## Usage
+
+### Check Installation
+
+```bash
+symfluence info
+```
+
+This shows:
+- Installed version
+- Platform information
+- Available tools
+- Build metadata
+- Binary directory path
+
+### Use Tools Directly
+
+#### Option 1: Add to PATH
+
+```bash
+# Bash/Zsh
+export PATH="$(npm root -g)/symfluence/dist/bin:$PATH"
+
+# Fish
+set -x PATH (npm root -g)/symfluence/dist/bin $PATH
+```
+
+Then run tools directly:
+```bash
+summa --version
+mizuroute --help
+ngen --version
+```
+
+#### Option 2: Use Full Path
+
+```bash
+$(npm root -g)/symfluence/dist/bin/summa --version
+```
+
+#### Option 3: Use with SYMFLUENCE Python Package
+
+```bash
+# Install Python package
+pip install symfluence
+
+# Configure to use npm-installed binaries
+export SYMFLUENCE_DATA="$(npm root -g)/symfluence/dist"
+```
+
+### Get Binary Directory
+
+```bash
+symfluence path
+```
+
+## Commands
+
+```bash
+symfluence info       # Show installation info and available tools
+symfluence version    # Show version
+symfluence path       # Show binary directory path
+symfluence help       # Show help
+```
+
+## Troubleshooting
+
+### Installation Fails
+
+1. **Check platform support**:
+   ```bash
+   node -e "console.log(process.platform, process.arch)"
+   ```
+   Must be `linux x64` or `darwin arm64`
+
+2. **Check internet connection**: Downloads from GitHub Releases
+
+3. **Verify release exists**:
+   https://github.com/DarriEy/SYMFLUENCE/releases
+
+4. **Try manual installation**: See repository README
+
+### "libnetcdf.so.19: not found" (Linux)
+
+Install required libraries:
+```bash
+sudo apt-get install libnetcdf19 libnetcdff7 libhdf5-103
+```
+
+### "dyld: Library not loaded" (macOS)
+
+Install required libraries:
+```bash
+brew install netcdf netcdf-fortran hdf5
+```
+
+### "version `GLIBC_2.35' not found" (Linux)
+
+Your system has an older glibc. Options:
+- Upgrade to Ubuntu 22.04+ / RHEL 9+ / Debian 12+
+- Build from source (see repository docs)
+- Use Docker (see repository docs)
+
+## Development
+
+### Local Testing
+
+```bash
+# In the npm/ directory
+npm install .          # Test installation
+node install.js        # Test download manually
+./bin/symfluence info  # Test CLI
+```
+
+### Publishing
+
+```bash
+# Update version in package.json to match release tag
+npm publish
+```
+
+## Documentation
+
+- **Repository**: https://github.com/DarriEy/SYMFLUENCE
+- **System Requirements**: [docs/SYSTEM_REQUIREMENTS.md](https://github.com/DarriEy/SYMFLUENCE/blob/main/docs/SYSTEM_REQUIREMENTS.md)
+- **Dynamic Linking Strategy**: [docs/DYNAMIC_LINKING_STRATEGY.md](https://github.com/DarriEy/SYMFLUENCE/blob/main/docs/DYNAMIC_LINKING_STRATEGY.md)
+- **Issues**: https://github.com/DarriEy/SYMFLUENCE/issues
+
+## License
+
+GPL-3.0 - See repository for details.
+
+## Contributing
+
+This package provides pre-built binaries only. For contributing to the tools themselves or the Python framework, see the main repository.
+
+## Credits
+
+- **SUMMA**: Martyn Clark and NCAR
+- **mizuRoute**: Naoki Mizukami and NCAR
+- **FUSE**: Martyn Clark
+- **NGEN**: NOAA-OWP
+- **TauDEM**: David Tarboton, Utah State University
+
+SYMFLUENCE framework developed by Darri Eythorsson.

package/bin/symfluence

@@ -0,0 +1,214 @@
+#!/usr/bin/env node
+/**
+ * SYMFLUENCE CLI wrapper
+ * Provides information about installed binaries and tools
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { getPlatformName } = require('../lib/platform');
+
+const distDir = path.join(__dirname, '..', 'dist');
+const binDir = path.join(distDir, 'bin');
+const toolchainFile = path.join(distDir, 'toolchain.json');
+
+/**
+ * Check if SYMFLUENCE binaries are installed
+ * @returns {boolean}
+ */
+function isInstalled() {
+  return fs.existsSync(distDir) && fs.existsSync(binDir);
+}
+
+/**
+ * Get list of installed tools
+ * @returns {Array<string>}
+ */
+function getInstalledTools() {
+  if (!fs.existsSync(binDir)) {
+    return [];
+  }
+
+  return fs.readdirSync(binDir)
+    .filter(f => {
+      const fullPath = path.join(binDir, f);
+      const stats = fs.statSync(fullPath);
+      return stats.isFile() && (stats.mode & 0o111); // Executable
+    })
+    .sort();
+}
+
+/**
+ * Read toolchain metadata
+ * @returns {Object|null}
+ */
+function getToolchain() {
+  if (!fs.existsSync(toolchainFile)) {
+    return null;
+  }
+
+  try {
+    return JSON.parse(fs.readFileSync(toolchainFile, 'utf8'));
+  } catch (err) {
+    return null;
+  }
+}
+
+/**
+ * Display help information
+ */
+function showHelp() {
+  console.log('SYMFLUENCE - Hydrological Modeling Framework\n');
+  console.log('Usage: symfluence [command]\n');
+  console.log('Commands:');
+  console.log('  info        Show installed tools and build information');
+  console.log('  version     Show version information');
+  console.log('  path        Show binary directory path');
+  console.log('  help        Show this help message\n');
+  console.log('Environment:');
+  console.log('  To use tools directly, add to your PATH:');
+  console.log(`  export PATH="$(npm root -g)/symfluence/dist/bin:$PATH"\n`);
+  console.log('Documentation: https://github.com/DarriEy/SYMFLUENCE');
+}
+
+/**
+ * Display version information
+ */
+function showVersion() {
+  const packageJson = require('../package.json');
+  const toolchain = getToolchain();
+
+  console.log(`symfluence v${packageJson.version}`);
+
+  if (toolchain) {
+    console.log(`Platform: ${toolchain.platform || 'unknown'}`);
+    console.log(`Build date: ${toolchain.build_date || 'unknown'}`);
+  }
+}
+
+/**
+ * Display installed tools and build information
+ */
+function showInfo() {
+  if (!isInstalled()) {
+    console.error('❌ SYMFLUENCE binaries not found.');
+    console.error('   Run: npm install -g symfluence');
+    process.exit(1);
+  }
+
+  const packageJson = require('../package.json');
+  const toolchain = getToolchain();
+  const tools = getInstalledTools();
+
+  console.log('╔════════════════════════════════════════════╗');
+  console.log('║   SYMFLUENCE Installation Info             ║');
+  console.log('╚════════════════════════════════════════════╝\n');
+
+  console.log(`📦 Version: ${packageJson.version}`);
+  console.log(`📍 Platform: ${getPlatformName()}`);
+
+  if (toolchain) {
+    console.log(`🔧 Build Platform: ${toolchain.platform || 'unknown'}`);
+    console.log(`📅 Build Date: ${toolchain.build_date || 'unknown'}`);
+
+    if (toolchain.compilers) {
+      console.log('\n🛠️  Compilers:');
+      if (toolchain.compilers.fortran) {
+        console.log(`   Fortran: ${toolchain.compilers.fortran}`);
+      }
+      if (toolchain.compilers.c) {
+        console.log(`   C: ${toolchain.compilers.c}`);
+      }
+    }
+
+    if (toolchain.libraries) {
+      console.log('\n📚 Libraries:');
+      if (toolchain.libraries.netcdf) {
+        console.log(`   NetCDF: ${toolchain.libraries.netcdf}`);
+      }
+      if (toolchain.libraries.hdf5) {
+        console.log(`   HDF5: ${toolchain.libraries.hdf5}`);
+      }
+    }
+  }
+
+  console.log('\n🔨 Installed Tools:');
+  if (tools.length === 0) {
+    console.log('   (none found)');
+  } else {
+    tools.forEach(tool => {
+      const toolPath = path.join(binDir, tool);
+      console.log(`   ✓ ${tool}`);
+
+      // Show additional info from toolchain if available
+      if (toolchain && toolchain.tools && toolchain.tools[tool]) {
+        const toolInfo = toolchain.tools[tool];
+        if (toolInfo.commit) {
+          console.log(`     Commit: ${toolInfo.commit.substring(0, 8)}`);
+        }
+        if (toolInfo.branch) {
+          console.log(`     Branch: ${toolInfo.branch}`);
+        }
+      }
+    });
+  }
+
+  console.log('\n📂 Binary Directory:');
+  console.log(`   ${binDir}`);
+
+  console.log('\n💡 Usage:');
+  console.log('   Add to PATH:');
+  console.log(`     export PATH="${binDir}:$PATH"`);
+  console.log('   Or use full path:');
+  if (tools.length > 0) {
+    console.log(`     ${path.join(binDir, tools[0])} --help`);
+  }
+
+  console.log('\n📖 Documentation:');
+  console.log('   https://github.com/DarriEy/SYMFLUENCE');
+  console.log('   https://github.com/DarriEy/SYMFLUENCE/blob/main/docs/SYSTEM_REQUIREMENTS.md\n');
+}
+
+/**
+ * Show binary directory path
+ */
+function showPath() {
+  if (!isInstalled()) {
+    console.error('❌ SYMFLUENCE binaries not found.');
+    process.exit(1);
+  }
+  console.log(binDir);
+}
+
+/**
+ * Main CLI entry point
+ */
+function main() {
+  const args = process.argv.slice(2);
+  const command = args[0] || 'help';
+
+  switch (command) {
+    case 'info':
+      showInfo();
+      break;
+
+    case 'version':
+    case '-v':
+    case '--version':
+      showVersion();
+      break;
+
+    case 'path':
+      showPath();
+      break;
+
+    case 'help':
+    case '-h':
+    case '--help':
+    default:
+      showHelp();
+      break;
+  }
+}
+
+main();

package/index.js

@@ -0,0 +1,124 @@
+/**
+ * SYMFLUENCE npm package - Programmatic API
+ * Provides access to binary paths and metadata
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { getPlatform, getPlatformName, isPlatformSupported } = require('./lib/platform');
+
+const DIST_DIR = path.join(__dirname, 'dist');
+const BIN_DIR = path.join(DIST_DIR, 'bin');
+const TOOLCHAIN_FILE = path.join(DIST_DIR, 'toolchain.json');
+
+/**
+ * Check if binaries are installed
+ * @returns {boolean}
+ */
+function isInstalled() {
+  return fs.existsSync(DIST_DIR) && fs.existsSync(BIN_DIR);
+}
+
+/**
+ * Get the binary directory path
+ * @returns {string|null} Path to bin directory, or null if not installed
+ */
+function getBinDir() {
+  return isInstalled() ? BIN_DIR : null;
+}
+
+/**
+ * Get path to a specific tool
+ * @param {string} toolName - Name of the tool (e.g., 'summa', 'mizuroute')
+ * @returns {string|null} Full path to tool, or null if not found
+ */
+function getToolPath(toolName) {
+  if (!isInstalled()) {
+    return null;
+  }
+
+  const toolPath = path.join(BIN_DIR, toolName);
+  return fs.existsSync(toolPath) ? toolPath : null;
+}
+
+/**
+ * Get list of installed tools
+ * @returns {Array<string>} Array of tool names
+ */
+function getInstalledTools() {
+  if (!isInstalled()) {
+    return [];
+  }
+
+  try {
+    return fs.readdirSync(BIN_DIR)
+      .filter(f => {
+        const fullPath = path.join(BIN_DIR, f);
+        const stats = fs.statSync(fullPath);
+        return stats.isFile() && (stats.mode & 0o111); // Executable
+      })
+      .sort();
+  } catch (err) {
+    return [];
+  }
+}
+
+/**
+ * Get toolchain metadata
+ * @returns {Object|null} Toolchain metadata, or null if not available
+ */
+function getToolchain() {
+  if (!fs.existsSync(TOOLCHAIN_FILE)) {
+    return null;
+  }
+
+  try {
+    return JSON.parse(fs.readFileSync(TOOLCHAIN_FILE, 'utf8'));
+  } catch (err) {
+    return null;
+  }
+}
+
+/**
+ * Get package version
+ * @returns {string}
+ */
+function getVersion() {
+  return require('./package.json').version;
+}
+
+/**
+ * Get all available paths for environment setup
+ * @returns {Object} Object with paths
+ */
+function getPaths() {
+  return {
+    dist: DIST_DIR,
+    bin: BIN_DIR,
+    toolchain: TOOLCHAIN_FILE,
+  };
+}
+
+module.exports = {
+  // Installation checks
+  isInstalled,
+  isPlatformSupported,
+
+  // Paths
+  getBinDir,
+  getToolPath,
+  getPaths,
+
+  // Tool information
+  getInstalledTools,
+  getToolchain,
+  getVersion,
+
+  // Platform information
+  getPlatform,
+  getPlatformName,
+
+  // Constants
+  DIST_DIR,
+  BIN_DIR,
+};

package/install.js

@@ -0,0 +1,270 @@
+#!/usr/bin/env node
+/**
+ * SYMFLUENCE npm installer
+ * Downloads and extracts pre-built binaries from GitHub Releases
+ */
+
+const fs = require('fs');
+const path = require('path');
+const https = require('https');
+const crypto = require('crypto');
+const { execSync } = require('child_process');
+const { getPlatform, getPlatformName } = require('./lib/platform');
+
+const PACKAGE_VERSION = require('./package.json').version;
+const GITHUB_REPO = 'DarriEy/SYMFLUENCE';
+
+/**
+ * Construct the download URL for the current platform
+ * @param {string} platform - Platform identifier (e.g., 'macos-arm64')
+ * @returns {string} Full download URL
+ */
+function getDownloadUrl(platform) {
+  const tag = `v${PACKAGE_VERSION}`;
+  const filename = `symfluence-tools-${tag}-${platform}.tar.gz`;
+  return `https://github.com/${GITHUB_REPO}/releases/download/${tag}/${filename}`;
+}
+
+/**
+ * Download a file from URL with progress tracking
+ * @param {string} url - URL to download from
+ * @param {string} dest - Destination file path
+ * @returns {Promise<void>}
+ */
+async function downloadFile(url, dest) {
+  return new Promise((resolve, reject) => {
+    const file = fs.createWriteStream(dest);
+
+    const request = https.get(url, {
+      headers: { 'User-Agent': 'symfluence-npm-installer' }
+    }, (response) => {
+      // Handle redirects
+      if (response.statusCode === 302 || response.statusCode === 301) {
+        file.close();
+        fs.unlinkSync(dest);
+        downloadFile(response.headers.location, dest).then(resolve).catch(reject);
+        return;
+      }
+
+      if (response.statusCode !== 200) {
+        file.close();
+        fs.unlinkSync(dest);
+        reject(new Error(
+          `Download failed: ${response.statusCode} ${response.statusMessage}\n` +
+          `URL: ${url}`
+        ));
+        return;
+      }
+
+      const totalBytes = parseInt(response.headers['content-length'], 10);
+      let downloadedBytes = 0;
+      let lastPercent = -1;
+
+      response.on('data', (chunk) => {
+        downloadedBytes += chunk.length;
+        const percent = Math.floor((downloadedBytes / totalBytes) * 100);
+
+        // Only update display every 5% to reduce output noise
+        if (percent !== lastPercent && percent % 5 === 0) {
+          const mb = (downloadedBytes / 1024 / 1024).toFixed(1);
+          const totalMb = (totalBytes / 1024 / 1024).toFixed(1);
+          process.stdout.write(`\r📥 Downloading... ${percent}% (${mb}/${totalMb} MB)`);
+          lastPercent = percent;
+        }
+      });
+
+      response.pipe(file);
+
+      file.on('finish', () => {
+        file.close();
+        console.log('\n✅ Download complete');
+        resolve();
+      });
+
+      file.on('error', (err) => {
+        fs.unlinkSync(dest);
+        reject(err);
+      });
+    });
+
+    request.on('error', (err) => {
+      if (fs.existsSync(dest)) {
+        fs.unlinkSync(dest);
+      }
+      reject(err);
+    });
+  });
+}
+
+/**
+ * Verify file checksum against published SHA256
+ * @param {string} file - Path to file to verify
+ * @param {string} checksumUrl - URL of .sha256 file
+ * @returns {Promise<void>}
+ */
+async function verifyChecksum(file, checksumUrl) {
+  console.log('🔐 Verifying checksum...');
+
+  try {
+    // Download checksum file
+    const checksumData = await new Promise((resolve, reject) => {
+      let data = '';
+      https.get(checksumUrl, {
+        headers: { 'User-Agent': 'symfluence-npm-installer' }
+      }, (res) => {
+        if (res.statusCode === 302 || res.statusCode === 301) {
+          // Follow redirect
+          https.get(res.headers.location, (redirectRes) => {
+            redirectRes.on('data', chunk => data += chunk);
+            redirectRes.on('end', () => resolve(data));
+          }).on('error', reject);
+          return;
+        }
+        res.on('data', chunk => data += chunk);
+        res.on('end', () => resolve(data));
+      }).on('error', reject);
+    });
+
+    // Extract expected hash (format: "hash  filename")
+    const expectedHash = checksumData.trim().split(/\s+/)[0];
+
+    // Calculate actual hash
+    const fileBuffer = fs.readFileSync(file);
+    const hash = crypto.createHash('sha256');
+    hash.update(fileBuffer);
+    const actualHash = hash.digest('hex');
+
+    if (expectedHash.toLowerCase() !== actualHash.toLowerCase()) {
+      throw new Error(
+        'Checksum mismatch! File may be corrupted.\n' +
+        `  Expected: ${expectedHash}\n` +
+        `  Actual:   ${actualHash}`
+      );
+    }
+
+    console.log('✅ Checksum verified');
+  } catch (err) {
+    console.warn('⚠️  Could not verify checksum:', err.message);
+    console.warn('   Proceeding anyway, but installation may be corrupted...');
+  }
+}
+
+/**
+ * Extract tarball to destination directory
+ * @param {string} tarball - Path to tarball
+ * @param {string} destDir - Destination directory
+ */
+function extractTarball(tarball, destDir) {
+  console.log('📦 Extracting binaries...');
+
+  // Use --strip-components=1 to remove the top-level directory
+  const extractCmd = `tar -xzf "${tarball}" -C "${destDir}" --strip-components=1`;
+
+  try {
+    execSync(extractCmd, { stdio: 'inherit' });
+    console.log('✅ Extraction complete');
+  } catch (err) {
+    throw new Error(`Extraction failed: ${err.message}`);
+  }
+}
+
+/**
+ * Main installation function
+ */
+async function install() {
+  console.log('╔════════════════════════════════════════════╗');
+  console.log('║   SYMFLUENCE Binary Installer              ║');
+  console.log('╚════════════════════════════════════════════╝\n');
+
+  // Detect platform
+  let platform;
+  try {
+    platform = getPlatform();
+  } catch (err) {
+    console.error('❌', err.message);
+    console.error('\n📖 For manual installation, see:');
+    console.error('   https://github.com/DarriEy/SYMFLUENCE#installation\n');
+    process.exit(1);
+  }
+
+  console.log(`📍 Platform: ${getPlatformName()} (${platform})`);
+  console.log(`📦 Version: ${PACKAGE_VERSION}\n`);
+
+  const url = getDownloadUrl(platform);
+  const checksumUrl = `${url}.sha256`;
+
+  console.log(`🔗 Downloading from GitHub Releases...`);
+  console.log(`   ${url}\n`);
+
+  const distDir = path.join(__dirname, 'dist');
+  const tarballPath = path.join(__dirname, 'symfluence-tools.tar.gz');
+
+  // Clean and create dist directory
+  if (fs.existsSync(distDir)) {
+    console.log('🧹 Cleaning previous installation...');
+    fs.rmSync(distDir, { recursive: true, force: true });
+  }
+  fs.mkdirSync(distDir, { recursive: true });
+
+  try {
+    // Download tarball
+    await downloadFile(url, tarballPath);
+
+    // Verify checksum
+    await verifyChecksum(tarballPath, checksumUrl);
+
+    // Extract
+    extractTarball(tarballPath, distDir);
+
+    // Cleanup tarball
+    fs.unlinkSync(tarballPath);
+
+    // Display installation info
+    console.log('\n╔════════════════════════════════════════════╗');
+    console.log('║   🎉 Installation Complete!                ║');
+    console.log('╚════════════════════════════════════════════╝\n');
+
+    console.log('📦 Installed Tools:');
+    const binDir = path.join(distDir, 'bin');
+    if (fs.existsSync(binDir)) {
+      const tools = fs.readdirSync(binDir).filter(f => {
+        const fullPath = path.join(binDir, f);
+        return fs.statSync(fullPath).isFile();
+      });
+      tools.forEach(tool => console.log(`   ✓ ${tool}`));
+    }
+
+    console.log('\n📖 Next Steps:');
+    console.log('   1. Check installation: symfluence --help');
+    console.log('   2. View available tools: ls $(npm root -g)/symfluence/dist/bin');
+    console.log('   3. Install Python package: pip install symfluence\n');
+
+    console.log('📚 Documentation: https://github.com/DarriEy/SYMFLUENCE\n');
+
+  } catch (err) {
+    console.error('\n❌ Installation failed:', err.message);
+    console.error('\n📖 Troubleshooting:');
+    console.error('   1. Check your internet connection');
+    console.error('   2. Verify the release exists:');
+    console.error(`      https://github.com/${GITHUB_REPO}/releases/tag/v${PACKAGE_VERSION}`);
+    console.error('   3. Check system requirements:');
+    console.error('      https://github.com/DarriEy/SYMFLUENCE/blob/main/docs/SYSTEM_REQUIREMENTS.md');
+    console.error('   4. Try manual installation:');
+    console.error('      https://github.com/DarriEy/SYMFLUENCE#installation\n');
+
+    // Clean up on failure
+    if (fs.existsSync(tarballPath)) {
+      fs.unlinkSync(tarballPath);
+    }
+    if (fs.existsSync(distDir)) {
+      fs.rmSync(distDir, { recursive: true, force: true });
+    }
+
+    process.exit(1);
+  }
+}
+
+// Run installer if executed directly (not required)
+if (require.main === module) {
+  install();
+}

package/lib/platform.js

@@ -0,0 +1,77 @@
+/**
+ * Platform detection and mapping for SYMFLUENCE binaries
+ */
+
+// Mapping from Node.js platform/arch to SYMFLUENCE release naming
+const PLATFORM_MAP = {
+  'darwin-arm64': 'macos-arm64',
+  'darwin-x64': 'macos-x64',      // Currently not supported, but reserved
+  'linux-x64': 'linux-x86_64',
+  'linux-arm64': 'linux-aarch64', // Future support
+};
+
+/**
+ * Get the current platform identifier for SYMFLUENCE releases
+ * @returns {string} Platform identifier (e.g., 'macos-arm64', 'linux-x86_64')
+ * @throws {Error} If platform is not supported
+ */
+function getPlatform() {
+  const platform = process.platform;
+  const arch = process.arch;
+  const key = `${platform}-${arch}`;
+
+  if (!PLATFORM_MAP[key]) {
+    throw new Error(
+      `Unsupported platform: ${platform} ${arch}\n` +
+      `Supported platforms: ${Object.keys(PLATFORM_MAP).join(', ')}\n` +
+      `Please file an issue at: https://github.com/DarriEy/SYMFLUENCE/issues`
+    );
+  }
+
+  return PLATFORM_MAP[key];
+}
+
+/**
+ * Check if current platform is supported
+ * @returns {boolean} True if platform is supported
+ */
+function isPlatformSupported() {
+  const platform = process.platform;
+  const arch = process.arch;
+  const key = `${platform}-${arch}`;
+  return key in PLATFORM_MAP;
+}
+
+/**
+ * Get user-friendly platform name
+ * @returns {string} Platform name for display
+ */
+function getPlatformName() {
+  const platform = process.platform;
+  const arch = process.arch;
+
+  const names = {
+    'darwin-arm64': 'macOS (Apple Silicon)',
+    'darwin-x64': 'macOS (Intel)',
+    'linux-x64': 'Linux (x86_64)',
+    'linux-arm64': 'Linux (ARM64)',
+  };
+
+  return names[`${platform}-${arch}`] || `${platform} ${arch}`;
+}
+
+/**
+ * Get all supported platforms
+ * @returns {Array<string>} List of supported platform identifiers
+ */
+function getSupportedPlatforms() {
+  return Object.values(PLATFORM_MAP);
+}
+
+module.exports = {
+  getPlatform,
+  isPlatformSupported,
+  getPlatformName,
+  getSupportedPlatforms,
+  PLATFORM_MAP,
+};

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "symfluence",
+  "version": "0.5.8",
+  "description": "Structure for Unifying Multiple Modeling Alternatives - Pre-compiled hydrological modeling tools",
+  "main": "index.js",
+  "bin": {
+    "symfluence": "bin/symfluence"
+  },
+  "scripts": {
+    "postinstall": "node install.js"
+  },
+  "os": [
+    "darwin",
+    "linux"
+  ],
+  "cpu": [
+    "x64",
+    "arm64"
+  ],
+  "engines": {
+    "node": ">=14"
+  },
+  "keywords": [
+    "hydrology",
+    "modeling",
+    "summa",
+    "mizuroute",
+    "ngen",
+    "fuse",
+    "taudem",
+    "scientific",
+    "water-resources"
+  ],
+  "author": "Darri Eythorsson",
+  "license": "GPL-3.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/DarriEy/SYMFLUENCE.git"
+  },
+  "homepage": "https://github.com/DarriEy/SYMFLUENCE",
+  "bugs": {
+    "url": "https://github.com/DarriEy/SYMFLUENCE/issues"
+  },
+  "preferGlobal": true,
+  "files": [
+    "bin/",
+    "lib/",
+    "dist/",
+    "install.js",
+    "README.md"
+  ]
+}