@paimaexample/npm-midnight-proof-server 0.3.15

package/binary.js

@@ -0,0 +1,69 @@
+const os = require("os");
+const fs = require("fs");
+const axios = require("axios");
+const extract = require("extract-zip");
+const path = require("path");
+
+/**
+ * Returns platform string matching the naming convention used for hosted binaries.
+ * Example outputs: linux-amd64, macos-arm64
+ */
+function getPlatform() {
+  const platform = os.platform();
+  let arch = os.arch();
+
+  if (arch === "x64") {
+    arch = "amd64";
+  }
+
+  // For macOS return macos-<arch> to allow unsupported detection
+  if (platform === "darwin") {
+    return `macos-${arch}`;
+  }
+
+  // Assume Linux or other UNIX variants default to arch only (amd64/arm64)
+  return arch;
+}
+
+function getBinaryUrl() {
+  const platform = getPlatform();
+  const supportedPlatforms = require("./package.json").supportedPlatforms;
+
+  if (!supportedPlatforms.includes(platform)) {
+    throw new Error(`Unsupported platform for binary execution: ${platform}`);
+  }
+
+  // TODO: Replace placeholder link with real URL once available
+  return `https://paima-midnight.nyc3.cdn.digitaloceanspaces.com/binaries/midnight-proof-server-${platform}.zip`;
+}
+
+async function downloadAndSaveBinary() {
+  const url = getBinaryUrl();
+  console.log(`Downloading midnight proof server binary from ${url}`);
+
+  const response = await axios.get(url, { responseType: "stream" });
+  const zipPath = path.join(__dirname, "proof-server.zip");
+  const writer = fs.createWriteStream(zipPath);
+
+  response.data.pipe(writer);
+
+  return new Promise((resolve, reject) => {
+    writer.on("finish", resolve);
+    writer.on("error", reject);
+  });
+}
+
+async function unzipBinary() {
+  const zipPath = path.join(__dirname, "proof-server.zip");
+  const destDir = path.join(__dirname, "proof-server");
+
+  await extract(zipPath, { dir: destDir });
+  fs.unlinkSync(zipPath);
+}
+
+async function binary() {
+  await downloadAndSaveBinary();
+  await unzipBinary();
+}
+
+module.exports = { binary, getPlatform };

package/docker.js

@@ -0,0 +1,124 @@
+const { spawn, exec, execSync } = require("child_process");
+const { promisify } = require("util");
+const execAsync = promisify(exec);
+
+const IMAGE_NAME = "midnightnetwork/proof-server";
+const CONTAINER_NAME = "midnight-proof-server";
+
+async function checkIfDockerExists() {
+  try {
+    await execAsync("docker --version");
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function pullDockerImage(tag = "latest") {
+  return new Promise((resolve, reject) => {
+    const child = spawn("docker", ["pull", `${IMAGE_NAME}:${tag}`], {
+      stdio: "inherit",
+    });
+    child.on(
+      "exit",
+      (
+        code,
+      ) => (code === 0
+        ? resolve()
+        : reject(new Error(`docker pull exited with ${code}`))),
+    );
+    child.on("error", reject);
+  });
+}
+
+/**
+ * Checks if a container with the given name exists (running or stopped)
+ * @param {string} containerName - Name of the container to check
+ * @returns {Promise<boolean>} True if container exists, false otherwise
+ */
+async function checkIfContainerExists(containerName) {
+  try {
+    const { stdout } = await execAsync(
+      `docker ps -aq -f name=^${containerName}$`,
+    );
+    return stdout.trim().length > 0;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Checks if a container is currently running
+ * @param {string} containerName - Name of the container to check
+ * @returns {Promise<boolean>} True if container is running, false otherwise
+ */
+async function checkIfContainerRunning(containerName) {
+  try {
+    const { stdout } = await execAsync(
+      `docker ps -q -f name=^${containerName}$`,
+    );
+    return stdout.trim().length > 0;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Runs the proof server container. Maps port 6300 by default. Additional CLI args are passed as command args.
+ * @param {Object} env Env vars to set inside container.
+ * @param {Array<string>} args CLI args.
+ * @param {string} tag Docker tag.
+ */
+async function runDockerContainer(
+  env = process.env,
+  args = [],
+  tag = "latest",
+) {
+  const containerExists = await checkIfContainerExists(CONTAINER_NAME);
+  const containerRunning = await checkIfContainerRunning(CONTAINER_NAME);
+
+  if (containerRunning) {
+    console.log(`Container ${CONTAINER_NAME} is already running`);
+    // Attach to the running container to see logs
+    const child = spawn("docker", ["logs", "-f", CONTAINER_NAME], {
+      stdio: "inherit",
+    });
+    return child;
+  }
+
+  if (containerExists) {
+    console.log(`Starting existing container: ${CONTAINER_NAME}`);
+    const child = spawn("docker", ["start", "-a", CONTAINER_NAME], {
+      stdio: "inherit",
+    });
+    return child;
+  }
+
+  // Container doesn't exist, create and run new one
+  console.log(`Creating new container: ${CONTAINER_NAME}`);
+
+  const dockerArgs = [
+    "run",
+    "--name",
+    CONTAINER_NAME,
+    "-p",
+    "6300:6300",
+  ];
+
+  // pass env vars
+  Object.entries(env).forEach(([k, v]) => {
+    if (v) dockerArgs.push("-e", `${k}=${v}`);
+  });
+
+  dockerArgs.push(`${IMAGE_NAME}:${tag}`);
+
+  if (args.length > 0) dockerArgs.push(...args);
+
+  console.log(
+    `Running proof server with Docker: docker ${dockerArgs.join(" ")}`,
+  );
+  const child = spawn("docker", dockerArgs, { stdio: "inherit" });
+  return child;
+}
+
+module.exports = { checkIfDockerExists, pullDockerImage, runDockerContainer };

package/index.js

@@ -0,0 +1,101 @@
+#!/usr/bin/env node
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+
+const { binary, getPlatform } = require("./binary.js");
+const { runMidnightProofServer } = require("./run_midnight_proof_server.js");
+const { checkIfDockerExists, pullDockerImage, runDockerContainer } = require(
+  "./docker.js",
+);
+
+function checkIfBinaryExists() {
+  return fs.existsSync(path.join(__dirname, "proof-server", "proof-server"));
+}
+
+function isBinarySupported() {
+  const supported = require("./package.json").supportedPlatforms;
+  return supported.includes(getPlatform());
+}
+
+function showUsage() {
+  console.log(`\nUsage: npm-midnight-proof-server [options] [args...]\n
+Options:
+  --docker    Force use of Docker container
+  --binary    Force binary execution (Linux only)
+  --help, -h  Show this help message\n`);
+}
+
+function parseFlags(argv) {
+  const flags = {
+    useDocker: false,
+    useBinary: false,
+    showHelp: false,
+    remaining: [],
+  };
+  for (const arg of argv) {
+    if (arg === "--docker") flags.useDocker = true;
+    else if (arg === "--binary") flags.useBinary = true;
+    else if (arg === "--help" || arg === "-h") flags.showHelp = true;
+    else flags.remaining.push(arg);
+  }
+  return flags;
+}
+
+async function runWithBinary(env, args) {
+  if (!checkIfBinaryExists()) {
+    console.log("Binary not found, downloading...");
+    await binary();
+  }
+  return runMidnightProofServer(env, args);
+}
+
+async function runWithDocker(env, args) {
+  if (!(await checkIfDockerExists())) {
+    console.error("Docker is required but not installed or not running.");
+    process.exit(1);
+  }
+  await pullDockerImage();
+  return runDockerContainer(env, args);
+}
+
+(async () => {
+  const flags = parseFlags(process.argv.slice(2));
+  const env = process.env;
+
+  if (flags.showHelp) {
+    showUsage();
+    process.exit(0);
+  }
+
+  if (flags.useDocker && flags.useBinary) {
+    console.error("Cannot use both --docker and --binary flags simultaneously");
+    process.exit(1);
+  }
+
+  if (flags.useDocker) {
+    await runWithDocker(env, flags.remaining);
+    return;
+  }
+
+  if (flags.useBinary) {
+    if (!isBinarySupported()) {
+      console.error(
+        `Binary execution not supported on platform ${getPlatform()}`,
+      );
+      process.exit(1);
+    }
+    await runWithBinary(env, flags.remaining);
+    return;
+  }
+
+  // Automatic selection
+  if (isBinarySupported()) {
+    await runWithBinary(env, flags.remaining);
+  } else {
+    console.log(
+      "Binary not supported on this platform, falling back to Docker...",
+    );
+    await runWithDocker(env, flags.remaining);
+  }
+})();

package/package.json

@@ -0,0 +1,23 @@
+{
+    "name": "@paimaexample/npm-midnight-proof-server",
+    "version": "0.3.15",
+    "description": "A wrapper for the Midnight proof server binary",
+    "main": "index.js",
+    "bin": {
+        "npm-midnight-proof-server": "index.js"
+    },
+    "scripts": {
+        "start": "node index.js"
+    },
+    "supportedPlatforms": [
+        "linux-amd64",
+        "linux-arm64"
+    ],
+    "dependencies": {
+        "axios": "^1.6.8",
+        "extract-zip": "^2.0.1"
+    },
+    "type": "commonjs",
+    "author": "Paima Studios",
+    "license": "ISC"
+}

package/run_midnight_proof_server.js

@@ -0,0 +1,43 @@
+const { spawn } = require("child_process");
+const path = require("path");
+const { getPlatform } = require("./binary.js");
+
+/**
+ * Executes the midnight-proof-server binary as a child process.
+ * @param {Object} env Environment variables to pass to the child process.
+ * @param {Array<string>} args Optional CLI arguments to forward to the binary.
+ * @returns {import('child_process').ChildProcess}
+ */
+function runMidnightProofServer(env = process.env, args = []) {
+  const platform = getPlatform();
+  const binaryName = `midnight-proof-server-${platform}`;
+  const binaryPath = path.join(__dirname, "proof-server", binaryName);
+
+  console.log(`Starting midnight proof server binary at: ${binaryPath}`);
+
+  const child = spawn(binaryPath, args, {
+    env,
+    stdio: "inherit",
+    cwd: path.join(__dirname, "proof-server"),
+  });
+
+  child.on("spawn", () => {
+    console.log(`midnight-proof-server spawned with PID: ${child.pid}`);
+  });
+
+  child.on("error", (error) => {
+    console.error("Failed to start midnight proof server:", error);
+  });
+
+  child.on("exit", (code, signal) => {
+    if (code !== null) {
+      console.log(`midnight proof server exited with code: ${code}`);
+    } else {
+      console.log(`midnight proof server terminated by signal: ${signal}`);
+    }
+  });
+
+  return child;
+}
+
+module.exports = { runMidnightProofServer };