gitpreflight 0.1.4

package/bin/gitpreflight.js

@@ -0,0 +1,34 @@
+#!/usr/bin/env node
+
+"use strict";
+
+const { spawn } = require("node:child_process");
+const { ensureGitPreflightBinary } = require("../lib/installer");
+
+async function main() {
+  const args = process.argv.slice(2);
+  const { binPath } = await ensureGitPreflightBinary({ reason: "run" });
+
+  const child = spawn(binPath, args, {
+    stdio: "inherit",
+    env: process.env
+  });
+
+  child.on("exit", (code, signal) => {
+    if (typeof code === "number") process.exit(code);
+    process.exitCode = 1;
+    if (signal) {
+      process.stderr.write(`GitPreflight exited due to signal: ${signal}\n`);
+    }
+  });
+
+  child.on("error", (err) => {
+    process.stderr.write(`Failed to start GitPreflight: ${err?.message ?? String(err)}\n`);
+    process.exit(2);
+  });
+}
+
+Promise.resolve(main()).catch((err) => {
+  process.stderr.write(`GitPreflight installer error: ${err?.message ?? String(err)}\n`);
+  process.exit(2);
+});

package/bin/postinstall.js

@@ -0,0 +1,42 @@
+#!/usr/bin/env node
+
+"use strict";
+
+const { ensureGitPreflightBinary } = require("../lib/installer");
+
+async function main() {
+  const interactive = Boolean(process.stdout.isTTY) && Boolean(process.stderr.isTTY) && process.env.CI !== "1" && process.env.CI !== "true";
+
+  if (process.env.GITPREFLIGHT_SKIP_DOWNLOAD === "1" || process.env.GITPREFLIGHT_SKIP_DOWNLOAD === "true") {
+    if (interactive) {
+      process.stderr.write("GitPreflight: run `gitpreflight install` to choose setup mode (global, local, or repo).\n");
+    }
+    return;
+  }
+
+  // Avoid noisy downloads during local development (workspace version is usually 0.0.0).
+  if (!process.env.GITPREFLIGHT_INSTALL_VERSION) {
+    try {
+      const version = require("../package.json").version;
+      if (version === "0.0.0") {
+        if (interactive) {
+          process.stderr.write("GitPreflight: run `gitpreflight install` to choose setup mode (global, local, or repo).\n");
+        }
+        return;
+      }
+    } catch {
+      return;
+    }
+  }
+
+  await ensureGitPreflightBinary({ reason: "postinstall" });
+
+  if (interactive) {
+    process.stderr.write("GitPreflight installed. Next: run `gitpreflight install` to configure hooks.\n");
+  }
+}
+
+Promise.resolve(main()).catch((err) => {
+  // Never fail install for transient network issues.
+  process.stderr.write(`GitPreflight: postinstall download skipped (${err?.message ?? String(err)})\n`);
+});

package/lib/installer.js

@@ -0,0 +1,243 @@
+"use strict";
+
+const fs = require("node:fs");
+const fsp = require("node:fs/promises");
+const path = require("node:path");
+const os = require("node:os");
+const http = require("node:http");
+const https = require("node:https");
+const crypto = require("node:crypto");
+
+const DEFAULT_GITHUB_REPO = "un/gitpreflight";
+
+function isTruthy(v) {
+  return v === "1" || v === "true" || v === "yes";
+}
+
+function getPackageVersion() {
+  try {
+    return require("../package.json").version;
+  } catch {
+    return "0.0.0";
+  }
+}
+
+function resolveTarget() {
+  const platform = process.platform;
+  const arch = process.arch;
+
+  if (platform !== "darwin" && platform !== "linux") {
+    throw new Error(`Unsupported platform: ${platform}. GitPreflight supports macOS and Linux.`);
+  }
+  if (arch !== "x64" && arch !== "arm64") {
+    throw new Error(`Unsupported architecture: ${arch}. GitPreflight supports x64 and arm64.`);
+  }
+
+  return { platform, arch };
+}
+
+function resolveCachePaths(version) {
+  const home = os.homedir();
+  const base = process.env.GITPREFLIGHT_HOME && process.env.GITPREFLIGHT_HOME.trim()
+    ? process.env.GITPREFLIGHT_HOME.trim()
+    : path.join(home, ".gitpreflight");
+
+  const dir = path.join(base, "bin", version);
+  const binPath = path.join(dir, "gitpreflight");
+  return { dir, binPath };
+}
+
+function request(url) {
+  return new Promise((resolve, reject) => {
+    const u = new URL(url);
+    const client = u.protocol === "https:" ? https : u.protocol === "http:" ? http : null;
+    if (!client) {
+      reject(new Error(`Unsupported URL protocol: ${u.protocol}`));
+      return;
+    }
+
+    const req = client.get(
+      u,
+      {
+        headers: {
+          "user-agent": "gitpreflight-installer",
+          accept: "application/octet-stream"
+        }
+      },
+      (res) => {
+        resolve(res);
+      }
+    );
+
+    req.setTimeout(30_000, () => {
+      req.destroy(new Error(`Timeout downloading ${url}`));
+    });
+
+    req.on("error", reject);
+  });
+}
+
+async function downloadText(url, maxRedirects = 5) {
+  const res = await request(url);
+
+  if (
+    (res.statusCode === 301 || res.statusCode === 302 || res.statusCode === 307 || res.statusCode === 308) &&
+    res.headers.location &&
+    maxRedirects > 0
+  ) {
+    res.resume();
+    const next = new URL(res.headers.location, url).toString();
+    return downloadText(next, maxRedirects - 1);
+  }
+
+  if (!res.statusCode || res.statusCode < 200 || res.statusCode >= 300) {
+    const body = await streamToString(res);
+    throw new Error(`HTTP ${res.statusCode ?? "?"} downloading ${url}${body ? `: ${body.trim()}` : ""}`);
+  }
+
+  return streamToString(res);
+}
+
+async function downloadFile(url, destPath, maxRedirects = 5) {
+  const res = await request(url);
+
+  if (
+    (res.statusCode === 301 || res.statusCode === 302 || res.statusCode === 307 || res.statusCode === 308) &&
+    res.headers.location &&
+    maxRedirects > 0
+  ) {
+    res.resume();
+    const next = new URL(res.headers.location, url).toString();
+    return downloadFile(next, destPath, maxRedirects - 1);
+  }
+
+  if (!res.statusCode || res.statusCode < 200 || res.statusCode >= 300) {
+    const body = await streamToString(res);
+    throw new Error(`HTTP ${res.statusCode ?? "?"} downloading ${url}${body ? `: ${body.trim()}` : ""}`);
+  }
+
+  await fsp.mkdir(path.dirname(destPath), { recursive: true });
+
+  await new Promise((resolve, reject) => {
+    const out = fs.createWriteStream(destPath);
+    res.pipe(out);
+    res.on("error", reject);
+    out.on("error", reject);
+    out.on("finish", resolve);
+  });
+}
+
+function streamToString(stream) {
+  return new Promise((resolve, reject) => {
+    let data = "";
+    stream.setEncoding("utf8");
+    stream.on("data", (chunk) => {
+      data += chunk;
+    });
+    stream.on("error", reject);
+    stream.on("end", () => resolve(data));
+  });
+}
+
+async function sha256File(absPath) {
+  const h = crypto.createHash("sha256");
+  await new Promise((resolve, reject) => {
+    const s = fs.createReadStream(absPath);
+    s.on("data", (chunk) => h.update(chunk));
+    s.on("error", reject);
+    s.on("end", resolve);
+  });
+  return h.digest("hex");
+}
+
+function parseChecksums(text) {
+  const lines = text.split(/\r?\n/);
+  const map = new Map();
+  for (const line of lines) {
+    const t = line.trim();
+    if (!t) continue;
+    const m = t.match(/^([a-f0-9]{64})\s{2}(.+)$/i);
+    if (!m) continue;
+    map.set(m[2].trim(), m[1].toLowerCase());
+  }
+  return map;
+}
+
+async function fileExists(p) {
+  try {
+    await fsp.access(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function chmod755(p) {
+  try {
+    await fsp.chmod(p, 0o755);
+  } catch {
+    // best-effort
+  }
+}
+
+async function ensureGitPreflightBinary(opts) {
+  const version = (process.env.GITPREFLIGHT_INSTALL_VERSION && process.env.GITPREFLIGHT_INSTALL_VERSION.trim()) || getPackageVersion();
+  const repo = (process.env.GITPREFLIGHT_GITHUB_REPO && process.env.GITPREFLIGHT_GITHUB_REPO.trim()) || DEFAULT_GITHUB_REPO;
+
+  const baseUrlOverride = process.env.GITPREFLIGHT_INSTALL_BASE_URL && process.env.GITPREFLIGHT_INSTALL_BASE_URL.trim()
+    ? process.env.GITPREFLIGHT_INSTALL_BASE_URL.trim().replace(/\/+$/, "")
+    : null;
+
+  if (!version) {
+    throw new Error("Could not determine GitPreflight version to install");
+  }
+
+  if (version === "0.0.0" && !baseUrlOverride) {
+    throw new Error(
+      "GitPreflight is running from a source checkout (version 0.0.0). " +
+        "Build from source, or set GITPREFLIGHT_INSTALL_VERSION to a released version."
+    );
+  }
+
+  const { platform, arch } = resolveTarget();
+  const assetName = `gitpreflight-v${version}-${platform}-${arch}`;
+  const base = baseUrlOverride ?? `https://github.com/${repo}/releases/download/v${version}`;
+  const assetUrl = `${base}/${assetName}`;
+  const checksumsUrl = `${base}/checksums.txt`;
+
+  const { dir, binPath } = resolveCachePaths(version);
+  if (await fileExists(binPath)) {
+    return { binPath, version, platform, arch, assetName, repo, cached: true };
+  }
+
+  await fsp.mkdir(dir, { recursive: true });
+  const tmpPath = path.join(dir, `gitpreflight.tmp-${process.pid}-${Date.now()}`);
+
+  if (!isTruthy(process.env.GITPREFLIGHT_QUIET_INSTALL) && opts?.reason !== "postinstall") {
+    process.stderr.write(`GitPreflight: downloading ${assetName}...\n`);
+  }
+
+  await downloadFile(assetUrl, tmpPath);
+
+  const checksumsText = await downloadText(checksumsUrl);
+  const checksums = parseChecksums(checksumsText);
+  const expected = checksums.get(assetName);
+  if (!expected) {
+    throw new Error(`Missing checksum for ${assetName} in checksums.txt`);
+  }
+
+  const actual = await sha256File(tmpPath);
+  if (actual !== expected) {
+    throw new Error(`Checksum mismatch for ${assetName} (expected ${expected}, got ${actual})`);
+  }
+
+  await chmod755(tmpPath);
+  await fsp.rename(tmpPath, binPath);
+  await chmod755(binPath);
+
+  return { binPath, version, platform, arch, assetName, repo, cached: false };
+}
+
+module.exports = {
+  ensureGitPreflightBinary
+};

package/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "gitpreflight",
+  "version": "0.1.4",
+  "description": "GitPreflight CLI installer/wrapper (downloads the platform binary)",
+  "bin": {
+    "gitpreflight": "bin/gitpreflight.js"
+  },
+  "files": [
+    "bin",
+    "lib"
+  ],
+  "scripts": {
+    "postinstall": "node bin/postinstall.js"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}