ztnet-cli 0.1.12

package/LICENSE

@@ -0,0 +1,8 @@
+GNU Affero General Public License v3.0 (AGPL-3.0-only)
+
+This npm package is distributed under the same license as the upstream project:
+https://github.com/JKamsker/ztnet-cli
+
+You can find the full license text at:
+https://www.gnu.org/licenses/agpl-3.0.txt
+

package/README.md

@@ -0,0 +1,21 @@
+# ztnet-cli (npm)
+
+This package installs the prebuilt **ZTNet CLI** (`ztnet`) for your platform.
+
+## Install
+
+```bash
+npm install -g ztnet-cli
+ztnet --help
+```
+
+## How it works
+
+On install, `ztnet-cli` downloads the matching `ztnet` binary from the GitHub Releases for the same version.
+
+Supported platforms:
+
+- Windows (x64)
+- Linux (x64)
+- macOS (arm64, x64)
+

package/artifacts/ztnet-0.1.12-aarch64-apple-darwin.tar.gz.sha256

@@ -0,0 +1 @@
+51ae0a72def91ab25aace355f44fd8c6feb34a848f8630eb307c9204e1f2fe7a  ztnet-0.1.12-aarch64-apple-darwin.tar.gz

package/artifacts/ztnet-0.1.12-x86_64-pc-windows-msvc.zip.sha256

@@ -0,0 +1 @@
+7c6fd2c3c4fcc2cafd40f20b14ded78f8c31bbf4ae195d1b07562b9c435d0017  ztnet-0.1.12-x86_64-pc-windows-msvc.zip

package/artifacts/ztnet-0.1.12-x86_64-unknown-linux-gnu.tar.gz.sha256

@@ -0,0 +1 @@
+3138263312e945b64f0b72c75f817cc74909aba551bcfabfa42d10502cc4977f  ztnet-0.1.12-x86_64-unknown-linux-gnu.tar.gz

package/bin/ztnet.js

@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+
+const childProcess = require("node:child_process");
+const fs = require("node:fs");
+const path = require("node:path");
+
+const packageRoot = path.join(__dirname, "..");
+const vendorDir = path.join(packageRoot, "vendor");
+const exeName = process.platform === "win32" ? "ztnet.exe" : "ztnet";
+const exePath = path.join(vendorDir, exeName);
+
+if (!fs.existsSync(exePath)) {
+  console.error(`[ztnet-cli] Missing native binary: ${exePath}`);
+  console.error(
+    "[ztnet-cli] Reinstall to re-run the downloader: npm install -g ztnet-cli",
+  );
+  process.exit(1);
+}
+
+const result = childProcess.spawnSync(exePath, process.argv.slice(2), {
+  stdio: "inherit",
+});
+
+if (result.error) {
+  console.error(`[ztnet-cli] Failed to run ${exePath}: ${result.error.message}`);
+  process.exit(1);
+}
+
+process.exit(result.status ?? 1);
+

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "ztnet-cli",
+  "version": "0.1.12",
+  "description": "ZTNet CLI \u2014 manage ZeroTier networks via ZTNet",
+  "license": "AGPL-3.0-only",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/JKamsker/ztnet-cli.git"
+  },
+  "homepage": "https://github.com/JKamsker/ztnet-cli",
+  "bugs": {
+    "url": "https://github.com/JKamsker/ztnet-cli/issues"
+  },
+  "bin": {
+    "ztnet": "bin/ztnet.js"
+  },
+  "files": [
+    "bin/",
+    "artifacts/",
+    "scripts/",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "postinstall": "node scripts/install.js"
+  },
+  "dependencies": {
+    "extract-zip": "^2.0.1",
+    "tar": "^6.2.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/scripts/install.js

@@ -0,0 +1,235 @@
+const crypto = require("node:crypto");
+const fs = require("node:fs");
+const https = require("node:https");
+const os = require("node:os");
+const path = require("node:path");
+
+const extractZip = require("extract-zip");
+const tar = require("tar");
+
+function resolvePlatformTarget() {
+  const platform = process.platform;
+  const arch = process.arch;
+
+  if (platform === "win32" && arch === "x64") {
+    return { target: "x86_64-pc-windows-msvc", archiveExt: "zip", exe: "ztnet.exe" };
+  }
+
+  if (platform === "linux" && arch === "x64") {
+    return { target: "x86_64-unknown-linux-gnu", archiveExt: "tar.gz", exe: "ztnet" };
+  }
+
+  if (platform === "darwin" && arch === "arm64") {
+    return { target: "aarch64-apple-darwin", archiveExt: "tar.gz", exe: "ztnet" };
+  }
+
+  if (platform === "darwin" && arch === "x64") {
+    return { target: "x86_64-apple-darwin", archiveExt: "tar.gz", exe: "ztnet" };
+  }
+
+  return null;
+}
+
+function readPackageJsonVersion(packageRoot) {
+  const pkgJsonPath = path.join(packageRoot, "package.json");
+  const pkg = JSON.parse(fs.readFileSync(pkgJsonPath, "utf8"));
+  if (!pkg?.version) throw new Error("Failed to read version from package.json");
+  return String(pkg.version);
+}
+
+function httpGet(url) {
+  return new Promise((resolve, reject) => {
+    https
+      .get(
+        url,
+        {
+          headers: {
+            "User-Agent": "ztnet-cli-npm-installer",
+            Accept: "application/octet-stream",
+          },
+        },
+        (res) => {
+          const code = res.statusCode ?? 0;
+
+          if (code >= 300 && code < 400 && res.headers.location) {
+            res.resume();
+            resolve(httpGet(res.headers.location));
+            return;
+          }
+
+          if (code !== 200) {
+            const chunks = [];
+            res.on("data", (c) => chunks.push(c));
+            res.on("end", () => {
+              const body = Buffer.concat(chunks).toString("utf8").slice(0, 3000);
+              reject(new Error(`GET ${url} failed: HTTP ${code}\n${body}`));
+            });
+            return;
+          }
+
+          const chunks = [];
+          res.on("data", (c) => chunks.push(c));
+          res.on("end", () => resolve(Buffer.concat(chunks)));
+          res.on("error", reject);
+        },
+      )
+      .on("error", reject);
+  });
+}
+
+function downloadToFile(url, outPath) {
+  return new Promise((resolve, reject) => {
+    https
+      .get(
+        url,
+        {
+          headers: {
+            "User-Agent": "ztnet-cli-npm-installer",
+            Accept: "application/octet-stream",
+          },
+        },
+        (res) => {
+          const code = res.statusCode ?? 0;
+
+          if (code >= 300 && code < 400 && res.headers.location) {
+            res.resume();
+            resolve(downloadToFile(res.headers.location, outPath));
+            return;
+          }
+
+          if (code !== 200) {
+            const chunks = [];
+            res.on("data", (c) => chunks.push(c));
+            res.on("end", () => {
+              const body = Buffer.concat(chunks).toString("utf8").slice(0, 3000);
+              reject(new Error(`Download ${url} failed: HTTP ${code}\n${body}`));
+            });
+            return;
+          }
+
+          const file = fs.createWriteStream(outPath);
+          res.pipe(file);
+
+          file.on("finish", () => file.close(resolve));
+          file.on("error", (err) => {
+            try {
+              fs.unlinkSync(outPath);
+            } catch {
+              // ignore
+            }
+            reject(err);
+          });
+        },
+      )
+      .on("error", reject);
+  });
+}
+
+function sha256File(filePath) {
+  return new Promise((resolve, reject) => {
+    const hash = crypto.createHash("sha256");
+    const stream = fs.createReadStream(filePath);
+    stream.on("data", (chunk) => hash.update(chunk));
+    stream.on("error", reject);
+    stream.on("end", () => resolve(hash.digest("hex")));
+  });
+}
+
+function ensureDir(dirPath) {
+  fs.mkdirSync(dirPath, { recursive: true });
+}
+
+function safeCopyFile(src, dest) {
+  ensureDir(path.dirname(dest));
+  fs.copyFileSync(src, dest);
+}
+
+async function main() {
+  const packageRoot = path.join(__dirname, "..");
+  const resolved = resolvePlatformTarget();
+
+  if (!resolved) {
+    console.error(
+      `[ztnet-cli] Unsupported platform/arch: ${process.platform}/${process.arch}`,
+    );
+    process.exit(1);
+  }
+
+  const version = readPackageJsonVersion(packageRoot);
+  const repo = process.env.ZTNET_CLI_GITHUB_REPO || "JKamsker/ztnet-cli";
+  const tag = `v${version}`;
+
+  const asset = `ztnet-${version}-${resolved.target}.${resolved.archiveExt}`;
+  const assetUrl = `https://github.com/${repo}/releases/download/${tag}/${asset}`;
+  const shaUrl = `${assetUrl}.sha256`;
+  const localArtifactsDir = path.join(packageRoot, "artifacts");
+  const localArchivePath = path.join(localArtifactsDir, asset);
+  const localShaPath = `${localArchivePath}.sha256`;
+
+  const vendorDir = path.join(packageRoot, "vendor");
+  ensureDir(vendorDir);
+  const destBinary = path.join(vendorDir, resolved.exe);
+
+  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "ztnet-cli-"));
+  const archivePath = path.join(tmpDir, asset);
+  const extractDir = path.join(tmpDir, "extract");
+  ensureDir(extractDir);
+
+  try {
+    const usingBundledAsset =
+      fs.existsSync(localArchivePath) && fs.existsSync(localShaPath);
+
+    const shaText = usingBundledAsset
+      ? fs.readFileSync(localShaPath, "utf8").trim()
+      : (await httpGet(shaUrl)).toString("utf8").trim();
+    const expectedHash = shaText.split(/\s+/)[0]?.trim();
+    if (!expectedHash || !/^[0-9a-fA-F]{64}$/.test(expectedHash)) {
+      const source = usingBundledAsset ? localShaPath : shaUrl;
+      throw new Error(`Invalid SHA256 file at ${source}`);
+    }
+
+    const actualArchivePath = usingBundledAsset ? localArchivePath : archivePath;
+
+    if (!usingBundledAsset) {
+      await downloadToFile(assetUrl, archivePath);
+    }
+
+    const actualHash = await sha256File(actualArchivePath);
+    if (actualHash.toLowerCase() !== expectedHash.toLowerCase()) {
+      throw new Error(
+        `SHA256 mismatch for ${asset}\nExpected: ${expectedHash}\nActual:   ${actualHash}`,
+      );
+    }
+
+    if (resolved.archiveExt === "zip") {
+      await extractZip(actualArchivePath, { dir: extractDir });
+    } else if (resolved.archiveExt === "tar.gz") {
+      await tar.x({ file: actualArchivePath, cwd: extractDir });
+    } else {
+      throw new Error(`Unsupported archive type: ${resolved.archiveExt}`);
+    }
+
+    const extractedBinary = path.join(extractDir, resolved.exe);
+    if (!fs.existsSync(extractedBinary)) {
+      throw new Error(`Expected extracted binary not found: ${extractedBinary}`);
+    }
+
+    safeCopyFile(extractedBinary, destBinary);
+
+    if (process.platform !== "win32") {
+      fs.chmodSync(destBinary, 0o755);
+    }
+  } finally {
+    try {
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    } catch {
+      // ignore
+    }
+  }
+}
+
+main().catch((err) => {
+  console.error(`[ztnet-cli] Install failed: ${err?.message || String(err)}`);
+  process.exit(1);
+});
+

package/scripts/verify-version.js

@@ -0,0 +1,20 @@
+const fs = require("node:fs");
+const path = require("node:path");
+
+const expected = process.env.VERSION;
+if (!expected) {
+  console.error("[ztnet-cli] VERSION env var is required");
+  process.exit(1);
+}
+
+const pkgPath = path.join(__dirname, "..", "package.json");
+const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+const actual = String(pkg?.version ?? "");
+
+if (actual !== String(expected)) {
+  console.error(
+    `[ztnet-cli] npm/package.json version ${actual} != ${String(expected)}`,
+  );
+  process.exit(1);
+}
+