singularity-forge/rust-engine/scripts/build.js

#!/usr/bin/env node

/**
 * Build script for the SF native Rust addon.
 *
 * Usage:
 *   node native/scripts/build.js          # release build
 *   node native/scripts/build.js --dev    # debug build
 *
 * Runs `cargo build` in the engine crate directory and copies the resulting
 * shared library to `native/addon/` with a `.node` extension so Node.js
 * can load it via `require()`.
 */

import { execSync } from "node:child_process";
import * as fs from "node:fs";
import * as path from "node:path";

const nativeRoot = path.resolve(import.meta.dirname, "..");
const engineDir = path.join(nativeRoot, "crates", "engine");
const addonDir = path.join(nativeRoot, "addon");

const isDev = process.argv.includes("--dev");
const profile = isDev ? "debug" : "release";
const cargoArgs = ["build"];
if (!isDev) cargoArgs.push("--release");

function shellValue(command) {
  try {
    return execSync(command, {
      stdio: ["ignore", "pipe", "ignore"],
      env: process.env,
    }).toString().trim() || undefined;
  } catch {
    return undefined;
  }
}

function getZlibLibDir() {
  return (
    process.env.ZLIB_LIB_DIR ||
    shellValue("pkg-config --variable=libdir zlib")
  );
}

function getCargoEnvironment() {
  const zlibLibDir = getZlibLibDir();
  const defaultRustFlags = process.env.RUSTFLAGS || "-C target-cpu=native";
  const rustFlags = zlibLibDir && !defaultRustFlags.includes(zlibLibDir)
    ? `${defaultRustFlags} -L native=${zlibLibDir}`
    : defaultRustFlags;
  const libraryPath = [zlibLibDir, process.env.LIBRARY_PATH]
    .filter(Boolean)
    .join(path.delimiter);

  return {
    ...process.env,
    // Optimize for native CPU when building locally
    RUSTFLAGS: rustFlags,
    ...(libraryPath ? { LIBRARY_PATH: libraryPath } : {}),
  };
}

function getCargoTargetDirectory() {
  if (process.env.CARGO_TARGET_DIR) {
    return path.resolve(process.env.CARGO_TARGET_DIR);
  }

  const metadataRaw = execSync("cargo metadata --format-version 1 --no-deps", {
    cwd: engineDir,
    stdio: ["ignore", "pipe", "inherit"],
    env: getCargoEnvironment(),
  }).toString();
  const metadata = JSON.parse(metadataRaw);
  if (typeof metadata.target_directory !== "string" || metadata.target_directory.length === 0) {
    throw new Error("cargo metadata did not return a target_directory");
  }
  return path.resolve(metadata.target_directory);
}

console.log(`Building forge-engine (${profile})...`);

try {
  execSync(`cargo ${cargoArgs.join(" ")}`, {
    cwd: engineDir,
    stdio: "inherit",
    env: getCargoEnvironment(),
  });
} catch {
  process.exit(1);
}

// Locate the built library using Cargo's actual target directory. Under Nix this
// is often redirected to a shared cache path rather than native/target.
const cargoTargetRoot = getCargoTargetDirectory();

const targetDir = path.join(cargoTargetRoot, profile);
const platformTag = `${process.platform}-${process.arch}`;

const libraryNames = {
  darwin: "libforge_engine.dylib",
  linux: "libforge_engine.so",
  win32: "forge_engine.dll",
};

const libName = libraryNames[process.platform];
if (!libName) {
  console.error(`Unsupported platform: ${process.platform}`);
  process.exit(1);
}

const sourcePath = path.join(targetDir, libName);
if (!fs.existsSync(sourcePath)) {
  console.error(`Built library not found at: ${sourcePath}`);
  process.exit(1);
}

fs.mkdirSync(addonDir, { recursive: true });

const destFilename = isDev
  ? "forge_engine.dev.node"
  : `forge_engine.${platformTag}.node`;
const destPath = path.join(addonDir, destFilename);

fs.copyFileSync(sourcePath, destPath);
console.log(`Installed: ${destPath}`);

// Also copy into the npm platform package so `require('@singularity-forge/engine-<platform>')`
// works when the package is symlinked into node_modules during local development.
if (!isDev) {
  const platformPackageMap = {
    "darwin-arm64": "darwin-arm64",
    "darwin-x64": "darwin-x64",
    "linux-x64": "linux-x64-gnu",
    "linux-arm64": "linux-arm64-gnu",
    "win32-x64": "win32-x64-msvc",
  };
  const npmSuffix = platformPackageMap[platformTag];
  if (npmSuffix) {
    const npmPackageDir = path.join(nativeRoot, "npm", npmSuffix);
    const npmDest = path.join(npmPackageDir, "forge_engine.node");
    if (fs.existsSync(npmPackageDir)) {
      fs.copyFileSync(sourcePath, npmDest);
      console.log(`Installed npm package binary: ${npmDest}`);
    }
  }
}

console.log("Build complete.");