@nexgensys/nexgit 0.1.3 → 0.1.6

package/README.md

@@ -12,14 +12,15 @@ npm install -g @nexgensys/nexgit
 nexgit --help
 ```
 
-El paquete incluye un lanzador que descarga el binario de la release correspondiente a tu plataforma
-(alpine/musl no está soportado), verifica su SHA-256 y lo ejecuta. La primera ejecución descarga
-unos 35 MB; después se reutiliza la copia en caché.
+El binario de tu plataforma llega como dependencia opcional (`@nexgensys/nexgit-<os>-<arch>`), así
+que no hay descargas en tiempo de ejecución. Alpine/musl no está soportado. Si la plataforma no
+tiene paquete, o se define `NEXGIT_BINARY`, el lanzador descarga la release, verifica su SHA-256 y la
+guarda en caché.
 
 - Plataformas: linux (amd64, arm64, armv7), macOS (amd64, arm64), Windows (amd64, arm64),
   FreeBSD (amd64, arm64).
 - Variables: `NEXGIT_BINARY` usa un binario local sin descargar; `NEXGIT_CACHE_DIR` cambia la caché;
   `NEXGIT_DOWNLOAD_URL` apunta a otro origen de releases.
-- Documentación completa: <https://git.nexgen.systems/IANexgen@nexgensys/nexgit>.
+- Documentación completa: <https://git.nexgen.systems/IANexgen/nexgit>.
 
 Licencia MIT.

package/bin/nexgit.js

@@ -0,0 +1,148 @@
+#!/usr/bin/env node
+
+// Launcher for the nexgit binary. Platform packages carry the binary; when one is not installed
+// (an unsupported platform, or a manual install), it falls back to downloading the release asset,
+// verifying its SHA-256 and caching it.
+const { spawnSync } = require("node:child_process");
+const { createHash } = require("node:crypto");
+const fs = require("node:fs");
+const os = require("node:os");
+const path = require("node:path");
+const https = require("node:https");
+
+const pkg = require("../package.json");
+const version = pkg.version;
+
+const platforms = {
+  "linux-x64": { asset: "linux-amd64", pkg: "linux-x64" },
+  "linux-arm64": { asset: "linux-arm64", pkg: "linux-arm64" },
+  "linux-arm": { asset: "linux-arm-7", pkg: "linux-arm" },
+  "darwin-x64": { asset: "darwin-amd64", pkg: "darwin-x64" },
+  "darwin-arm64": { asset: "darwin-arm64", pkg: "darwin-arm64" },
+  "win32-x64": { asset: "windows-amd64", pkg: "win32-x64" },
+  "win32-arm64": { asset: "windows-arm64", pkg: "win32-arm64" },
+  "freebsd-x64": { asset: "freebsd-amd64", pkg: "freebsd-x64" },
+  "freebsd-arm64": { asset: "freebsd-arm64", pkg: "freebsd-arm64" },
+};
+
+function platform() {
+  const key = `${process.platform}-${process.arch}`;
+  const found = platforms[key];
+  if (!found) {
+    throw new Error(`unsupported platform ${key}; install nexgit with its install script`);
+  }
+  const binary = process.platform === "win32" ? "nexgit.exe" : "nexgit";
+  return { ...found, binary, file: `nexgit-${version}-${found.asset}${process.platform === "win32" ? ".exe" : ""}` };
+}
+
+function packagedBinary(target) {
+  try {
+    const metadata = require.resolve(`@nexgensys/nexgit-${target.pkg}/package.json`);
+    return path.join(path.dirname(metadata), target.binary);
+  } catch {
+    return "";
+  }
+}
+
+function downloadBase() {
+  return (process.env.NEXGIT_DOWNLOAD_URL ||
+    "https://git.nexgen.systems/IANexgen/nexgit/releases/download").replace(/\/+$/, "");
+}
+
+function cacheDir() {
+  if (process.env.NEXGIT_CACHE_DIR) return process.env.NEXGIT_CACHE_DIR;
+  const base = process.env.XDG_CACHE_HOME || path.join(os.homedir(), ".cache");
+  return path.join(base, "nexgit", version);
+}
+
+function headers() {
+  const result = { "User-Agent": `nexgit-npm/${version}` };
+  if (process.env.NEXGIT_TOKEN) result.Authorization = `token ${process.env.NEXGIT_TOKEN}`;
+  return result;
+}
+
+function get(url, redirects = 0) {
+  return new Promise((resolve, reject) => {
+    if (redirects > 5) return reject(new Error(`too many redirects for ${url}`));
+    https
+      .get(url, { headers: headers() }, (response) => {
+        if (response.statusCode >= 300 && response.statusCode < 400 && response.headers.location) {
+          response.resume();
+          resolve(get(new URL(response.headers.location, url).toString(), redirects + 1));
+          return;
+        }
+        if (response.statusCode !== 200) {
+          response.resume();
+          reject(new Error(`${url} answered HTTP ${response.statusCode}`));
+          return;
+        }
+        resolve(response);
+      })
+      .on("error", reject);
+  });
+}
+
+async function download(url, target) {
+  const response = await get(url);
+  await new Promise((resolve, reject) => {
+    const out = fs.createWriteStream(target);
+    response.pipe(out);
+    out.on("finish", resolve);
+    out.on("error", reject);
+    response.on("error", reject);
+  });
+}
+
+async function text(url) {
+  const response = await get(url);
+  const chunks = [];
+  for await (const chunk of response) chunks.push(chunk);
+  return Buffer.concat(chunks).toString("utf8");
+}
+
+async function downloadBinary(target) {
+  const base = downloadBase();
+  const binary = path.join(cacheDir(), target.file);
+  if (fs.existsSync(binary)) return binary;
+  fs.mkdirSync(path.dirname(binary), { recursive: true });
+  const expected = (await text(`${base}/v${version}/${target.file}.sha256`)).trim().split(/\s+/)[0];
+  if (!/^[0-9a-f]{64}$/i.test(expected)) {
+    throw new Error(`invalid checksum for ${target.file}; set NEXGIT_TOKEN if the instance requires sign-in`);
+  }
+  const temporary = `${binary}.${process.pid}.tmp`;
+  console.error(`nexgit: downloading ${target.file} ${version}`);
+  await download(`${base}/v${version}/${target.file}`, temporary);
+  const digest = createHash("sha256").update(fs.readFileSync(temporary)).digest("hex");
+  if (digest !== expected.toLowerCase()) {
+    fs.rmSync(temporary, { force: true });
+    throw new Error(`checksum mismatch for ${target.file}; nexgit was not installed`);
+  }
+  fs.chmodSync(temporary, 0o755);
+  fs.renameSync(temporary, binary);
+  return binary;
+}
+
+async function main() {
+  if (process.env.NEXGIT_BINARY) return process.env.NEXGIT_BINARY;
+  const target = platform();
+  const installed = packagedBinary(target);
+  if (installed && fs.existsSync(installed)) {
+    fs.chmodSync(installed, 0o755);
+    return installed;
+  }
+  return downloadBinary(target);
+}
+
+main()
+  .then((binary) => {
+    const result = spawnSync(binary, process.argv.slice(2), { stdio: "inherit" });
+    if (result.error) {
+      console.error(`nexgit: ${result.error.message}`);
+      process.exit(1);
+    }
+    process.exit(result.status === null ? 1 : result.status);
+  })
+  .catch((error) => {
+    console.error(`nexgit: ${error.message}`);
+    process.exit(1);
+  });

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@nexgensys/nexgit",
-  "version": "0.1.3",
+  "version": "0.1.6",
   "description": "CLI de git.nexgen.systems: repositorios, issues, pull requests, releases y Actions desde la terminal",
   "license": "MIT",
   "bin": {
-    "nexgit": "bin@nexgensys/nexgit.js"
+    "nexgit": "bin/nexgit.js"
   },
   "files": [
     "bin@nexgensys/nexgit.js",
@@ -29,5 +29,16 @@
     "nexgit",
     "pull-requests",
     "actions"
-  ]
+  ],
+  "optionalDependencies": {
+    "@nexgensys/nexgit-linux-x64": "0.1.6",
+    "@nexgensys/nexgit-linux-arm64": "0.1.6",
+    "@nexgensys/nexgit-linux-arm": "0.1.6",
+    "@nexgensys/nexgit-darwin-x64": "0.1.6",
+    "@nexgensys/nexgit-darwin-arm64": "0.1.6",
+    "@nexgensys/nexgit-win32-x64": "0.1.6",
+    "@nexgensys/nexgit-win32-arm64": "0.1.6",
+    "@nexgensys/nexgit-freebsd-x64": "0.1.6",
+    "@nexgensys/nexgit-freebsd-arm64": "0.1.6"
+  }
 }