@pulseengine/rivet 0.7.0

package/README.md

@@ -0,0 +1,40 @@
+# @pulseengine/rivet
+
+SDLC traceability, validation, and MCP server for safety-critical systems.
+
+Rivet links requirements, features, architecture, decisions, and verification
+evidence across ISO 26262, DO-178C, ASPICE, and STPA. This npm package bundles
+the `rivet` CLI binary (shipped per-platform via `optionalDependencies`) so it
+can be invoked from any Node.js environment — including as a Claude Code MCP
+server.
+
+## Install
+
+```bash
+# One-shot (no install) — preferred for CI and MCP registration
+npx @pulseengine/rivet --version
+
+# Global install
+npm install -g @pulseengine/rivet
+rivet --version
+```
+
+## Claude Code MCP server
+
+```bash
+claude mcp add rivet npx -y @pulseengine/rivet mcp
+```
+
+## Supported platforms
+
+- `darwin-arm64`, `darwin-x64`
+- `linux-arm64`, `linux-x64`
+- `win32-x64`
+
+Binaries are pre-built and published alongside each GitHub release at
+<https://github.com/pulseengine/rivet/releases>.
+
+## License
+
+Apache-2.0. See the [repository](https://github.com/pulseengine/rivet) for
+source, documentation, and issues.

package/index.js

@@ -0,0 +1,101 @@
+#!/usr/bin/env node
+
+// Platform detection and binary-path resolution for @pulseengine/rivet.
+// Chooses the correct platform-specific optional dependency, or falls back
+// to a locally downloaded binary under ./bin (populated by install.js when
+// optionalDependencies fail to resolve — e.g., on an unsupported platform
+// triplet or with --no-optional).
+
+const os = require("os");
+const path = require("path");
+
+/**
+ * Map (process.platform, process.arch) to the matching @pulseengine platform
+ * package name. Throws for unsupported combinations so the caller can surface
+ * a clear error.
+ */
+function getPlatformPackageName() {
+  const platform = os.platform();
+  const arch = os.arch();
+
+  let platformName;
+  switch (platform) {
+    case "darwin":
+      platformName = "darwin";
+      break;
+    case "linux":
+      platformName = "linux";
+      break;
+    case "win32":
+      platformName = "win32";
+      break;
+    default:
+      throw new Error(`Unsupported platform: ${platform}`);
+  }
+
+  let archName;
+  switch (arch) {
+    case "x64":
+      archName = "x64";
+      break;
+    case "arm64":
+      archName = "arm64";
+      break;
+    default:
+      throw new Error(`Unsupported architecture: ${arch}`);
+  }
+
+  return `@pulseengine/rivet-${platformName}-${archName}`;
+}
+
+/**
+ * Resolve the absolute path to the rivet binary for the current platform.
+ * Prefers the optional-dependency platform package; falls back to ./bin
+ * (populated by install.js downloading from the GitHub Release).
+ */
+function getBinaryPath() {
+  const platform = os.platform();
+  const binaryName = platform === "win32" ? "rivet.exe" : "rivet";
+
+  try {
+    const platformPackage = getPlatformPackageName();
+    const platformPackagePath = require.resolve(`${platformPackage}/package.json`);
+    const platformPackageDir = path.dirname(platformPackagePath);
+    return path.join(platformPackageDir, binaryName);
+  } catch (_err) {
+    // Fallback: binary downloaded directly from GitHub release by install.js.
+    return path.join(__dirname, "bin", binaryName);
+  }
+}
+
+function getPlatformInfo() {
+  return {
+    platform: os.platform(),
+    arch: os.arch(),
+    platformPackage: getPlatformPackageName(),
+    binaryPath: getBinaryPath(),
+    binaryName: os.platform() === "win32" ? "rivet.exe" : "rivet",
+  };
+}
+
+module.exports = {
+  getPlatformPackageName,
+  getBinaryPath,
+  getPlatformInfo,
+};
+
+// When invoked directly, print platform info (useful for debugging installs).
+if (require.main === module) {
+  try {
+    const info = getPlatformInfo();
+    console.log("Platform Information:");
+    console.log(`  Platform:         ${info.platform}`);
+    console.log(`  Architecture:     ${info.arch}`);
+    console.log(`  Platform Package: ${info.platformPackage}`);
+    console.log(`  Binary Name:      ${info.binaryName}`);
+    console.log(`  Binary Path:      ${info.binaryPath}`);
+  } catch (err) {
+    console.error("Error:", err.message);
+    process.exit(1);
+  }
+}

package/install.js

@@ -0,0 +1,175 @@
+#!/usr/bin/env node
+
+// Post-install hook for @pulseengine/rivet.
+//
+// Preferred path: the platform-specific optional dependency
+// (@pulseengine/rivet-<platform>-<arch>) is already resolved and ships its
+// own pre-built binary — nothing to do.
+//
+// Fallback path: optionalDependencies were skipped (e.g., --no-optional,
+// unusual platform triplet, or npm bug) — download the matching archive
+// from the GitHub Release and extract the binary into ./bin so run.js can
+// find it.
+
+const os = require("os");
+const path = require("path");
+const fs = require("fs");
+const https = require("https");
+const { execFileSync } = require("child_process");
+
+const { getPlatformPackageName } = require("./index.js");
+
+// Fast path: platform package resolved => nothing to do.
+try {
+  const platformPackage = getPlatformPackageName();
+  try {
+    require.resolve(`${platformPackage}/package.json`);
+    console.log(`Platform package ${platformPackage} is available, skipping binary download.`);
+    process.exit(0);
+  } catch (_err) {
+    console.log(
+      `Platform package ${platformPackage} not found, falling back to GitHub release download.`,
+    );
+  }
+} catch (_err) {
+  console.log(
+    "Platform not supported by platform packages, attempting GitHub release download.",
+  );
+}
+
+// --- Fallback: download from GitHub release ---------------------------------
+
+function getRustTarget() {
+  const type = os.type();
+  const arch = os.arch();
+
+  let platform;
+  if (type === "Windows_NT") platform = "pc-windows-msvc";
+  else if (type === "Linux") platform = "unknown-linux-gnu";
+  else if (type === "Darwin") platform = "apple-darwin";
+  else throw new Error(`Unsupported OS: ${type}`);
+
+  let archSuffix;
+  if (arch === "x64") archSuffix = "x86_64";
+  else if (arch === "arm64") archSuffix = "aarch64";
+  else throw new Error(`Unsupported architecture: ${arch}`);
+
+  return `${archSuffix}-${platform}`;
+}
+
+function getBinaryName() {
+  return os.type() === "Windows_NT" ? "rivet.exe" : "rivet";
+}
+
+function getDownloadUrl() {
+  const version = require("./package.json").version;
+  const target = getRustTarget();
+  const ext = os.type() === "Windows_NT" ? "zip" : "tar.gz";
+  // release.yml uploads archives named: rivet-v<version>-<target>.<ext>
+  return `https://github.com/pulseengine/rivet/releases/download/v${version}/rivet-v${version}-${target}.${ext}`;
+}
+
+function downloadFile(url, destination) {
+  return new Promise((resolve, reject) => {
+    const file = fs.createWriteStream(destination);
+
+    https
+      .get(url, (response) => {
+        if (response.statusCode === 301 || response.statusCode === 302) {
+          file.close();
+          fs.unlink(destination, () => {});
+          return downloadFile(response.headers.location, destination)
+            .then(resolve)
+            .catch(reject);
+        }
+        if (response.statusCode !== 200) {
+          file.close();
+          fs.unlink(destination, () => {});
+          return reject(
+            new Error(`HTTP ${response.statusCode}: ${response.statusMessage} (${url})`),
+          );
+        }
+
+        response.pipe(file);
+        file.on("finish", () => {
+          file.close();
+          resolve();
+        });
+        file.on("error", (err) => {
+          fs.unlink(destination, () => {});
+          reject(err);
+        });
+      })
+      .on("error", (err) => {
+        fs.unlink(destination, () => {});
+        reject(err);
+      });
+  });
+}
+
+// Extract via execFile (no shell) to avoid any injection surface. Inputs are
+// already hardcoded paths we just constructed, but the argv form is the
+// correct idiom regardless.
+function extractArchive(archivePath, destDir) {
+  if (os.type() === "Windows_NT") {
+    execFileSync(
+      "powershell",
+      [
+        "-NoProfile",
+        "-Command",
+        `Expand-Archive -Path '${archivePath}' -DestinationPath '${destDir}' -Force`,
+      ],
+      { stdio: "inherit" },
+    );
+  } else {
+    execFileSync("tar", ["-xzf", archivePath, "-C", destDir], { stdio: "inherit" });
+  }
+}
+
+async function installBinary() {
+  const binaryName = getBinaryName();
+  const url = getDownloadUrl();
+  const target = getRustTarget();
+
+  console.log(`Platform: ${os.type()} ${os.arch()}`);
+  console.log(`Target:   ${target}`);
+  console.log(`Binary:   ${binaryName}`);
+  console.log(`URL:      ${url}`);
+
+  const binDir = path.join(__dirname, "bin");
+  if (!fs.existsSync(binDir)) fs.mkdirSync(binDir, { recursive: true });
+
+  const ext = os.type() === "Windows_NT" ? "zip" : "tar.gz";
+  const archivePath = path.join(binDir, `rivet.${ext}`);
+
+  console.log("Downloading binary...");
+  await downloadFile(url, archivePath);
+
+  console.log("Extracting...");
+  extractArchive(archivePath, binDir);
+
+  fs.unlinkSync(archivePath);
+
+  if (os.type() !== "Windows_NT") {
+    const binaryPath = path.join(binDir, binaryName);
+    if (fs.existsSync(binaryPath)) fs.chmodSync(binaryPath, 0o755);
+  }
+
+  console.log("rivet binary installed.");
+}
+
+installBinary().catch((err) => {
+  console.error("Failed to install rivet binary:", err.message);
+  console.error("");
+  console.error("You can:");
+  console.error("  1. Install from source:");
+  console.error(
+    "     cargo install --git https://github.com/pulseengine/rivet.git rivet-cli",
+  );
+  console.error("  2. Download a release manually:");
+  console.error("     https://github.com/pulseengine/rivet/releases");
+  // Do not fail the install: optionalDependencies are the primary path and a
+  // hard failure here would make `npm install` fail on platforms where the
+  // platform package was actually resolved (npm runs postinstall regardless).
+  process.exit(0);
+});

package/package.json

@@ -0,0 +1,67 @@
+{
+  "name": "@pulseengine/rivet",
+  "version": "0.7.0",
+  "description": "Rivet — SDLC traceability, validation, and MCP server for safety-critical systems (ISO 26262, DO-178C, ASPICE, STPA)",
+  "main": "index.js",
+  "bin": {
+    "rivet": "./run.js"
+  },
+  "scripts": {
+    "postinstall": "node install.js",
+    "preuninstall": "node uninstall.js"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "sdlc",
+    "traceability",
+    "safety",
+    "iso-26262",
+    "do-178c",
+    "aspice",
+    "stpa",
+    "requirements",
+    "verification",
+    "rust",
+    "cli"
+  ],
+  "author": "PulseEngine <https://github.com/pulseengine>",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/pulseengine/rivet.git"
+  },
+  "homepage": "https://github.com/pulseengine/rivet#readme",
+  "bugs": {
+    "url": "https://github.com/pulseengine/rivet/issues"
+  },
+  "optionalDependencies": {
+    "@pulseengine/rivet-darwin-arm64": "0.7.0",
+    "@pulseengine/rivet-darwin-x64": "0.7.0",
+    "@pulseengine/rivet-linux-arm64": "0.7.0",
+    "@pulseengine/rivet-linux-x64": "0.7.0",
+    "@pulseengine/rivet-win32-x64": "0.7.0"
+  },
+  "engines": {
+    "node": ">=14"
+  },
+  "os": [
+    "darwin",
+    "linux",
+    "win32"
+  ],
+  "cpu": [
+    "x64",
+    "arm64"
+  ],
+  "files": [
+    "index.js",
+    "install.js",
+    "run.js",
+    "uninstall.js",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/run.js

@@ -0,0 +1,65 @@
+#!/usr/bin/env node
+
+// Thin wrapper that spawns the rivet binary resolved via ./index.js.
+// Forwards argv, stdio, and exit code; propagates signals to the child.
+
+const { spawn } = require("child_process");
+const fs = require("fs");
+const { getBinaryPath } = require("./index.js");
+
+function runRivet() {
+  let binaryPath;
+  try {
+    binaryPath = getBinaryPath();
+  } catch (err) {
+    console.error("Error resolving rivet binary:", err.message);
+    console.error("");
+    console.error("Your platform may not be supported. Supported targets:");
+    console.error("  - darwin-arm64, darwin-x64");
+    console.error("  - linux-arm64, linux-x64");
+    console.error("  - win32-x64");
+    console.error("");
+    console.error(
+      "Install from source: cargo install --git https://github.com/pulseengine/rivet.git rivet-cli",
+    );
+    process.exit(1);
+  }
+
+  if (!fs.existsSync(binaryPath)) {
+    console.error("rivet binary not found at:", binaryPath);
+    console.error("");
+    console.error("This usually means:");
+    console.error("  1. optionalDependencies failed to install for your platform");
+    console.error("  2. The GitHub release fallback download failed");
+    console.error("  3. Your platform is not supported");
+    console.error("");
+    console.error("Try: npm install --force @pulseengine/rivet");
+    console.error(
+      "Or install from source: cargo install --git https://github.com/pulseengine/rivet.git rivet-cli",
+    );
+    process.exit(1);
+  }
+
+  const child = spawn(binaryPath, process.argv.slice(2), {
+    stdio: "inherit",
+    env: process.env,
+  });
+
+  child.on("error", (err) => {
+    console.error("Failed to start rivet:", err.message);
+    process.exit(1);
+  });
+
+  child.on("exit", (code, signal) => {
+    if (signal) {
+      process.kill(process.pid, signal);
+    } else {
+      process.exit(code == null ? 0 : code);
+    }
+  });
+
+  process.on("SIGINT", () => child.kill("SIGINT"));
+  process.on("SIGTERM", () => child.kill("SIGTERM"));
+}
+
+runRivet();

package/uninstall.js

@@ -0,0 +1,18 @@
+#!/usr/bin/env node
+
+// Pre-uninstall hook: remove binaries downloaded into ./bin by install.js.
+// Platform packages (optional deps) clean themselves up via normal npm
+// lifecycle — no action needed for those.
+
+const fs = require("fs");
+const path = require("path");
+
+const binDir = path.join(__dirname, "bin");
+
+if (fs.existsSync(binDir)) {
+  try {
+    fs.rmSync(binDir, { recursive: true, force: true });
+  } catch (err) {
+    console.error("Failed to clean rivet bin/:", err.message);
+  }
+}