wuphf 0.12.0

package/README.md

@@ -0,0 +1,37 @@
+# wuphf
+
+The pixel office CRM that reaches everyone, everywhere, all at once.
+
+## Install
+
+```bash
+npx wuphf
+```
+
+Or install globally:
+
+```bash
+npm install -g wuphf
+wuphf
+```
+
+Supported platforms: macOS and Linux on x64 or arm64.
+
+## How it works
+
+This package is a thin Node wrapper around the native `wuphf` Go binary.
+On install (or on first run, if postinstall was skipped), it downloads
+the matching release archive from
+[github.com/nex-crm/wuphf/releases](https://github.com/nex-crm/wuphf/releases)
+and places the binary in `node_modules/wuphf/bin/wuphf`.
+
+To point the wrapper at a local build, set `WUPHF_BINARY`:
+
+```bash
+WUPHF_BINARY=./wuphf npx wuphf --version
+```
+
+## Links
+
+- Source: https://github.com/nex-crm/wuphf
+- Issues: https://github.com/nex-crm/wuphf/issues

package/bin/wuphf.js

@@ -0,0 +1,46 @@
+#!/usr/bin/env node
+"use strict";
+
+// Thin shim that spawns the native wuphf binary. Downloads lazily on first
+// run if postinstall was skipped (common with `npm install --ignore-scripts`
+// and with some `npx` cache behaviors).
+
+const fs = require("node:fs");
+const path = require("node:path");
+const { spawn } = require("node:child_process");
+const { downloadBinary } = require("../scripts/download-binary");
+
+const binaryPath =
+  process.env.WUPHF_BINARY || path.join(__dirname, "wuphf");
+
+async function ensureBinary() {
+  if (process.env.WUPHF_BINARY && fs.existsSync(process.env.WUPHF_BINARY)) {
+    return process.env.WUPHF_BINARY;
+  }
+  if (fs.existsSync(binaryPath)) return binaryPath;
+  return downloadBinary();
+}
+
+function run(resolvedPath) {
+  const child = spawn(resolvedPath, process.argv.slice(2), {
+    stdio: "inherit",
+  });
+  child.on("exit", (code, signal) => {
+    if (signal) {
+      process.kill(process.pid, signal);
+    } else {
+      process.exit(code ?? 0);
+    }
+  });
+  child.on("error", (err) => {
+    process.stderr.write(`wuphf: failed to launch binary: ${err.message}\n`);
+    process.exit(1);
+  });
+}
+
+ensureBinary()
+  .then(run)
+  .catch((err) => {
+    process.stderr.write(`wuphf: ${err.message}\n`);
+    process.exit(1);
+  });

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "wuphf",
+  "version": "0.12.0",
+  "description": "WUPHF — pixel office CRM that reaches everyone, everywhere, all at once.",
+  "bin": {
+    "wuphf": "bin/wuphf.js"
+  },
+  "files": [
+    "bin/wuphf.js",
+    "scripts/download-binary.js",
+    "scripts/postinstall.js",
+    "README.md"
+  ],
+  "scripts": {
+    "postinstall": "node scripts/postinstall.js"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "os": [
+    "darwin",
+    "linux"
+  ],
+  "cpu": [
+    "x64",
+    "arm64"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/nex-crm/wuphf.git"
+  },
+  "homepage": "https://github.com/nex-crm/wuphf",
+  "bugs": {
+    "url": "https://github.com/nex-crm/wuphf/issues"
+  },
+  "license": "MIT",
+  "keywords": [
+    "wuphf",
+    "crm",
+    "cli",
+    "pixel-office",
+    "nex"
+  ]
+}

package/scripts/download-binary.js

@@ -0,0 +1,102 @@
+"use strict";
+
+// Downloads the wuphf binary that matches the current package version
+// from the corresponding GitHub release and extracts it into bin/.
+// GoReleaser archive name: wuphf_<version>_<os>_<arch>.tar.gz
+// where <version> is the tag without the leading 'v'.
+
+const fs = require("node:fs");
+const fsp = require("node:fs/promises");
+const path = require("node:path");
+const os = require("node:os");
+const { execFileSync } = require("node:child_process");
+
+const REPO = "nex-crm/wuphf";
+
+function detectPlatform() {
+  const platform = process.platform;
+  const arch = process.arch;
+
+  const osMap = { darwin: "darwin", linux: "linux" };
+  const archMap = { x64: "amd64", arm64: "arm64" };
+
+  if (!osMap[platform]) {
+    throw new Error(
+      `Unsupported platform: ${platform}. wuphf supports darwin and linux.`,
+    );
+  }
+  if (!archMap[arch]) {
+    throw new Error(
+      `Unsupported architecture: ${arch}. wuphf supports x64 (amd64) and arm64.`,
+    );
+  }
+  return { os: osMap[platform], arch: archMap[arch] };
+}
+
+function packageVersion() {
+  const pkg = JSON.parse(
+    fs.readFileSync(path.join(__dirname, "..", "package.json"), "utf8"),
+  );
+  return pkg.version;
+}
+
+function archiveUrl(version) {
+  const { os: goOs, arch: goArch } = detectPlatform();
+  const archive = `wuphf_${version}_${goOs}_${goArch}.tar.gz`;
+  return `https://github.com/${REPO}/releases/download/v${version}/${archive}`;
+}
+
+async function fetchToFile(url, dest) {
+  const res = await fetch(url, { redirect: "follow" });
+  if (!res.ok) {
+    throw new Error(`Download failed: ${res.status} ${res.statusText} (${url})`);
+  }
+  const buf = Buffer.from(await res.arrayBuffer());
+  await fsp.writeFile(dest, buf);
+}
+
+async function downloadBinary({ silent = false } = {}) {
+  const version = packageVersion();
+  const url = archiveUrl(version);
+  const binDir = path.join(__dirname, "..", "bin");
+  const binaryPath = path.join(binDir, "wuphf");
+
+  await fsp.mkdir(binDir, { recursive: true });
+
+  const tmpDir = await fsp.mkdtemp(path.join(os.tmpdir(), "wuphf-"));
+  const archivePath = path.join(tmpDir, "wuphf.tar.gz");
+
+  try {
+    if (!silent) {
+      process.stderr.write(`wuphf: downloading ${url}\n`);
+    }
+    await fetchToFile(url, archivePath);
+
+    // Extract using system tar (available on darwin + linux).
+    execFileSync("tar", ["-xzf", archivePath, "-C", tmpDir], {
+      stdio: silent ? "ignore" : "inherit",
+    });
+
+    const extractedBinary = path.join(tmpDir, "wuphf");
+    await fsp.copyFile(extractedBinary, binaryPath);
+    await fsp.chmod(binaryPath, 0o755);
+
+    // macOS 15+ invalidates GoReleaser's embedded ad-hoc signature after
+    // copy+chmod. Re-sign so the kernel does not SIGKILL on exec.
+    if (process.platform === "darwin") {
+      try {
+        execFileSync("codesign", ["--force", "--sign", "-", binaryPath], {
+          stdio: "ignore",
+        });
+      } catch {
+        // codesign is optional — binary may still run.
+      }
+    }
+
+    return binaryPath;
+  } finally {
+    await fsp.rm(tmpDir, { recursive: true, force: true });
+  }
+}
+
+module.exports = { downloadBinary, packageVersion };

package/scripts/postinstall.js

@@ -0,0 +1,19 @@
+"use strict";
+
+// Best-effort: fetch the binary at install time. Failures are non-fatal —
+// the bin/wuphf.js shim will retry on first invocation. This keeps
+// `npm install` from failing behind flaky networks or corporate proxies.
+
+const { downloadBinary } = require("./download-binary");
+
+if (process.env.WUPHF_SKIP_POSTINSTALL === "1") {
+  process.exit(0);
+}
+
+downloadBinary().catch((err) => {
+  process.stderr.write(
+    `wuphf: postinstall download failed (${err.message}). ` +
+      `The binary will be fetched on first run.\n`,
+  );
+  process.exit(0);
+});