[Init] Initial commit - NetMesh terminal manager

scripts/resolve-et-bin-release.cjs

@@ -0,0 +1,187 @@
+#!/usr/bin/env node
+/* eslint-disable no-console */
+//
+// Resolve the EternalTerminal `et` client binary release used by
+// build-packages.
+//
+// Priority:
+//   1. ET_BIN_RELEASE from workflow input / repository variable.
+//   2. Latest non-draft, non-prerelease GitHub Release whose tag is
+//      et-bin-* in ET_BIN_OWNER/ET_BIN_REPO. By default this is a
+//      dedicated sibling binary repository named Netcatty-et-bin.
+//
+// In GitHub Actions, the resolved tag is written back to $GITHUB_ENV so
+// later steps can run scripts/fetch-et-binaries.cjs without duplicating
+// release discovery logic.
+
+const fs = require("node:fs");
+const https = require("node:https");
+
+const TAG_RE = /^et-bin-[A-Za-z0-9._-]+$/;
+
+function log(msg) {
+  console.log(`[resolve-et-bin-release] ${msg}`);
+}
+
+function validateReleaseTag(tag) {
+  const value = String(tag || "").trim();
+  if (!TAG_RE.test(value)) {
+    throw new Error(`invalid et binary release tag: ${tag}`);
+  }
+  return value;
+}
+
+function parseRepository(env) {
+  const owner = env.ET_BIN_OWNER || (env.GITHUB_REPOSITORY || "").split("/")[0] || "binaricat";
+  const repo = env.ET_BIN_REPO || "Netcatty-et-bin";
+  return { owner, repo };
+}
+
+function releaseTimestamp(release) {
+  const raw = release.published_at || release.created_at || "";
+  const value = Date.parse(raw);
+  return Number.isNaN(value) ? 0 : value;
+}
+
+function pickLatestEtBinRelease(releases) {
+  return releases
+    .map((release, index) => ({ release, index }))
+    .filter(({ release }) => {
+      return release
+        && TAG_RE.test(String(release.tag_name || ""))
+        && release.draft !== true
+        && release.prerelease !== true;
+    })
+    .sort((a, b) => {
+      const diff = releaseTimestamp(b.release) - releaseTimestamp(a.release);
+      return diff || a.index - b.index;
+    })[0]?.release.tag_name;
+}
+
+function parseNextLink(linkHeader) {
+  if (!linkHeader) return null;
+  for (const part of String(linkHeader).split(",")) {
+    const match = part.match(/^\s*<([^>]+)>\s*;\s*(.+)\s*$/);
+    if (!match) continue;
+    const rel = match[2].split(";").some((attr) => attr.trim() === 'rel="next"');
+    if (rel) return match[1];
+  }
+  return null;
+}
+
+function requestJsonWithHeaders(url, env, depth = 0) {
+  return new Promise((resolve, reject) => {
+    if (depth > 5) {
+      reject(new Error("too many redirects while looking up et binary releases"));
+      return;
+    }
+
+    const headers = {
+      Accept: "application/vnd.github+json",
+      "User-Agent": "netcatty-et-release-resolver",
+      "X-GitHub-Api-Version": "2022-11-28",
+    };
+    const token = env.GITHUB_TOKEN || env.GH_TOKEN;
+    if (token) headers.Authorization = `Bearer ${token}`;
+
+    https.get(url, { headers }, (res) => {
+      const location = res.headers.location;
+      if (res.statusCode >= 300 && res.statusCode < 400 && location) {
+        res.resume();
+        resolve(requestJsonWithHeaders(new URL(location, url).toString(), env, depth + 1));
+        return;
+      }
+
+      const chunks = [];
+      res.on("data", (chunk) => chunks.push(chunk));
+      res.on("end", () => {
+        const body = Buffer.concat(chunks).toString("utf8");
+        if (res.statusCode !== 200) {
+          reject(new Error(`GitHub API returned HTTP ${res.statusCode}: ${body.slice(0, 300)}`));
+          return;
+        }
+        try {
+          resolve({ json: JSON.parse(body), headers: res.headers });
+        } catch (err) {
+          reject(new Error(`GitHub API returned invalid JSON: ${err.message}`));
+        }
+      });
+      res.on("error", reject);
+    }).on("error", reject);
+  });
+}
+
+async function loadReleases(env, request = requestJsonWithHeaders) {
+  if (env.ET_BIN_RELEASES_JSON) {
+    const parsed = JSON.parse(env.ET_BIN_RELEASES_JSON);
+    if (!Array.isArray(parsed)) {
+      throw new Error("ET_BIN_RELEASES_JSON must be a JSON array");
+    }
+    return parsed;
+  }
+
+  const { owner, repo } = parseRepository(env);
+  const apiBase = (env.GITHUB_API_URL || "https://api.github.com").replace(/\/+$/, "");
+  let url = `${apiBase}/repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}/releases?per_page=100`;
+  log(`looking up latest et-bin-* release in ${owner}/${repo}`);
+  const releases = [];
+  const seen = new Set();
+  while (url) {
+    if (seen.has(url)) {
+      throw new Error(`GitHub API pagination looped while looking up releases: ${url}`);
+    }
+    seen.add(url);
+
+    const { json, headers = {} } = await request(url, env);
+    if (!Array.isArray(json)) {
+      throw new Error("GitHub API releases response was not an array");
+    }
+    releases.push(...json);
+    url = parseNextLink(headers.link);
+  }
+  return releases;
+}
+
+function exportRelease(release, env) {
+  if (env.GITHUB_ENV) {
+    fs.appendFileSync(env.GITHUB_ENV, `ET_BIN_RELEASE=${release}\n`, "utf8");
+  }
+}
+
+async function main(env = process.env) {
+  if (String(env.ET_BIN_RELEASE || "").trim()) {
+    const release = validateReleaseTag(env.ET_BIN_RELEASE);
+    exportRelease(release, env);
+    log(`using ET_BIN_RELEASE=${release}`);
+    return release;
+  }
+
+  const releases = await loadReleases(env);
+  const release = pickLatestEtBinRelease(releases);
+  if (!release) {
+    throw new Error(
+      "could not find a non-draft et-bin-* release in the et binary repository. Publish build-et-binaries artifacts with release_tag (for example et-bin-6.2.10-1) before packaging.",
+    );
+  }
+
+  const validated = validateReleaseTag(release);
+  exportRelease(validated, env);
+  log(`resolved ET_BIN_RELEASE=${validated}`);
+  return validated;
+}
+
+if (require.main === module) {
+  main().catch((err) => {
+    console.error(`[resolve-et-bin-release] FATAL ${err.message}`);
+    process.exit(1);
+  });
+}
+
+module.exports = {
+  loadReleases,
+  parseNextLink,
+  validateReleaseTag,
+  parseRepository,
+  pickLatestEtBinRelease,
+  main,
+};