@nova-lang/cli 0.1.1 → 0.1.2

package/bin/nova.js

@@ -5,26 +5,49 @@ const { spawnSync } = require("child_process");
 const path = require("path");
 const fs = require("fs");
 
+const ROOT = path.resolve(__dirname, "..");
+
+function platformArch() {
+  const os = process.platform;
+  const a = process.arch;
+  const p = os === "darwin" ? "darwin" : os === "linux" ? "linux" : os === "win32" ? "win32" : null;
+  const ar = a === "x64" ? "x64" : a === "arm64" ? "arm64" : null;
+  if (!p || !ar) return null;
+  return p + "-" + ar;
+}
+
 function findBinary() {
-  const binName = process.platform === "win32" ? "nova.exe" : "nova";
+  const pa = platformArch();
+  const names = [];
 
-  const candidates = [
-    path.join(__dirname, "..", "zig-out", "bin", binName),
-    path.join(__dirname, "..", "bin", binName),
+  if (pa) {
+    const base = "nova-" + pa;
+    names.push(process.platform === "win32" ? base + ".exe" : base);
+  }
+
+  names.push(process.platform === "win32" ? "nova.exe" : "nova");
+
+  const dirs = [
+    path.join(ROOT, "bin"),
+    path.join(ROOT, "zig-out", "bin"),
   ];
 
   if (process.env.NOVA_BINARY) {
-    candidates.unshift(process.env.NOVA_BINARY);
+    dirs.unshift(path.dirname(process.env.NOVA_BINARY));
+    names.unshift(path.basename(process.env.NOVA_BINARY));
   }
 
-  for (const p of candidates) {
-    try {
-      if (fs.statSync(p).isFile()) {
-        return p;
-      }
-    } catch {}
+  for (const dir of dirs) {
+    for (const name of names) {
+      const p = path.join(dir, name);
+      try {
+        if (fs.statSync(p).isFile()) {
+          const mode = fs.statSync(p).mode;
+          if (mode & 0o111 || process.platform === "win32") return p;
+        }
+      } catch {}
+    }
   }
-
   return null;
 }
 
@@ -32,9 +55,9 @@ function main() {
   const binary = findBinary();
   if (!binary) {
     console.error(
-      "Nova Zig binary not found.\n" +
-        "  Build with: npm run build  (requires Zig compiler)\n" +
-        "  Or set:     NOVA_BINARY=/path/to/nova\n"
+      "Nova binary not found.\n" +
+      "  Reinstall: npm install @nova-lang/cli\n" +
+      "  Or set:    NOVA_BINARY=/path/to/nova\n"
     );
     process.exit(1);
   }

package/install.js

@@ -2,66 +2,183 @@
 "use strict";
 
 const { execSync, spawnSync } = require("child_process");
-const path = require("path");
 const fs = require("fs");
+const path = require("path");
+const https = require("https");
+const { createHash } = require("crypto");
 
 const ROOT = path.resolve(__dirname);
-const BIN_DIR = path.join(ROOT, "zig-out", "bin");
-const BIN_NAME = process.platform === "win32" ? "nova.exe" : "nova";
-const BIN_PATH = path.join(BIN_DIR, BIN_NAME);
+const BIN_DIR = path.join(ROOT, "bin");
+const PKG = JSON.parse(fs.readFileSync(path.join(ROOT, "package.json"), "utf-8"));
+const VERSION = PKG.version;
+
+function platform() {
+  const os = process.platform;
+  if (os === "darwin") return "darwin";
+  if (os === "linux") return "linux";
+  if (os === "win32") return "win32";
+  throw new Error("unsupported platform: " + os);
+}
+
+function arch() {
+  const a = process.arch;
+  if (a === "x64") return "x64";
+  if (a === "arm64") return "arm64";
+  throw new Error("unsupported arch: " + a);
+}
 
-function alreadyBuilt() {
+function binaryName() {
+  const base = ["nova", platform(), arch()].join("-");
+  return process.platform === "win32" ? base + ".exe" : base;
+}
+
+function binaryPath() {
+  return path.join(BIN_DIR, binaryName());
+}
+
+function binaryExists() {
   try {
-    return fs.statSync(BIN_PATH).isFile();
+    return fs.statSync(binaryPath()).isFile();
   } catch {
     return false;
   }
 }
 
+function downloadUrl() {
+  return [
+    "https://github.com/nova-lang/nova/releases/download",
+    "v" + VERSION,
+    binaryName(),
+  ].join("/");
+}
+
+function sha256Url() {
+  return downloadUrl() + ".sha256";
+}
+
+function download(url, dest) {
+  return new Promise((resolve, reject) => {
+    const file = fs.createWriteStream(dest);
+    https
+      .get(url, { timeout: 30000 }, (res) => {
+        if (res.statusCode === 302 || res.statusCode === 301) {
+          file.close();
+          fs.unlinkSync(dest);
+          return download(res.headers.location, dest).then(resolve).catch(reject);
+        }
+        if (res.statusCode !== 200) {
+          file.close();
+          fs.unlinkSync(dest);
+          return reject(new Error("HTTP " + res.statusCode + " for " + url));
+        }
+        res.pipe(file);
+        file.on("finish", () => {
+          file.close();
+          resolve();
+        });
+      })
+      .on("error", (err) => {
+        file.close();
+        try { fs.unlinkSync(dest); } catch {}
+        reject(err);
+      });
+  });
+}
+
+function verifyChecksum(filePath, expectedSha256) {
+  const hash = createHash("sha256");
+  const data = fs.readFileSync(filePath);
+  hash.update(data);
+  return hash.digest("hex") === expectedSha256.trim();
+}
+
+async function downloadBinary() {
+  const url = downloadUrl();
+  const dest = binaryPath();
+  const shaUrl = sha256Url();
+  const shaDest = dest + ".sha256";
+
+  console.log("nova: downloading " + url);
+
+  try {
+    await download(shaUrl, shaDest);
+    const expected = fs.readFileSync(shaDest, "utf-8").split(/\s+/)[0];
+    fs.unlinkSync(shaDest);
+
+    await download(url, dest);
+    fs.chmodSync(dest, 0o755);
+
+    if (!verifyChecksum(dest, expected)) {
+      fs.unlinkSync(dest);
+      throw new Error("sha256 mismatch");
+    }
+
+    console.log("nova: downloaded -> " + dest);
+    return true;
+  } catch (err) {
+    try { fs.unlinkSync(dest); } catch {}
+    try { fs.unlinkSync(shaDest); } catch {}
+    return false;
+  }
+}
+
 function findZig() {
   try {
     const r = spawnSync("which", ["zig"], { stdio: "pipe" });
-    if (r.status === 0) {
-      return r.stdout.toString().trim();
-    }
+    if (r.status === 0) return r.stdout.toString().trim();
   } catch {}
   try {
     const r = spawnSync("where", ["zig"], { stdio: "pipe", shell: true });
-    if (r.status === 0) {
-      return r.stdout.toString().trim().split("\n")[0];
-    }
+    if (r.status === 0) return r.stdout.toString().trim().split("\n")[0];
   } catch {}
   return null;
 }
 
-function build() {
-  if (alreadyBuilt()) {
-    console.log("nova: binary already built at " + BIN_PATH);
-    return;
-  }
-
+function buildFromSource() {
   const zig = findZig();
   if (!zig) {
     console.log(
-      "nova: Zig compiler not found. Skipping build.\n" +
-        "  Install Zig: https://ziglang.org/download/\n" +
-        "  Then run:     npm run build"
+      "nova: no pre-built binary for " + platform() + "-" + arch() + ".\n" +
+      "  Build from source: npm run build  (requires Zig compiler)\n" +
+      "  Or download: https://github.com/nova-lang/nova/releases"
     );
-    return;
+    return false;
   }
 
-  console.log("nova: building with " + zig + " ...");
-  const result = spawnSync(zig, ["build"], {
+  console.log("nova: building from source with " + zig + " ...");
+  const result = spawnSync(zig, ["build", "-Doptimize=ReleaseSafe"], {
     cwd: ROOT,
     stdio: "inherit",
   });
+  if (result.status !== 0) {
+    console.error("nova: build failed");
+    return false;
+  }
 
-  if (result.status === 0) {
-    console.log("nova: built successfully -> " + BIN_PATH);
-  } else {
-    console.error("nova: build failed (exit code " + result.status + ")");
-    process.exit(result.status ?? 1);
+  const built = path.join(ROOT, "zig-out", "bin", process.platform === "win32" ? "nova.exe" : "nova");
+  const dest = binaryPath();
+  if (fs.existsSync(built)) {
+    fs.mkdirSync(path.dirname(dest), { recursive: true });
+    fs.copyFileSync(built, dest);
+    fs.chmodSync(dest, 0o755);
+    console.log("nova: built -> " + dest);
+    return true;
   }
+  return false;
+}
+
+async function main() {
+  if (binaryExists()) {
+    return;
+  }
+
+  fs.mkdirSync(BIN_DIR, { recursive: true });
+
+  if (await downloadBinary()) return;
+  buildFromSource();
 }
 
-build();
+main().catch((err) => {
+  console.error("nova: install error:", err.message);
+  process.exit(1);
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nova-lang/cli",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "Nova: Nested Ordered Versatile Architecture — a programmable markup language CLI",
   "license": "MIT",
   "keywords": [