binary-collections 2.0.10 → 2.0.12

package/lib/chunk-66KDU4TX.mjs

@@ -0,0 +1,268 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  require_findEnvFiles
+} from "./chunk-H44UWUFY.mjs";
+import {
+  require_utils
+} from "./chunk-5RTXZVCW.mjs";
+import {
+  __toESM,
+  init_esm_shims
+} from "./chunk-QQ4A6DLD.mjs";
+
+// src/package-resolutions-updater.mjs
+init_esm_shims();
+var utils = __toESM(require_utils(), 1);
+var import_findEnvFiles = __toESM(require_findEnvFiles(), 1);
+import * as dotenv from "dotenv";
+import fs from "fs";
+import https from "https";
+import os from "os";
+import path from "path";
+import { parseGitHubUrl } from "git-command-helper";
+import axios from "axios";
+var projectDir = process.cwd();
+var envPath = path.join(projectDir, ".env");
+var args = utils.getArgs();
+if (!fs.existsSync(envPath)) {
+  const envFiles = (0, import_findEnvFiles.findEnvFiles)(projectDir, (file) => {
+    const content = fs.readFileSync(file, "utf-8");
+    return /GITHUB_TOKEN|ACCESS_TOKEN/.test(content);
+  });
+  if (envFiles.length > 0) {
+    envPath = envFiles[0];
+  }
+}
+if (fs.existsSync(envPath)) {
+  dotenv.config({ path: envPath, quiet: true, override: true });
+}
+var ACCESS_TOKEN = process.env.GITHUB_TOKEN || process.env.ACCESS_TOKEN;
+if (args.help || args.h) {
+  showHelp();
+}
+function showHelp() {
+  const helpText = `
+GitHub Package Resolutions Updater
+Usage:
+  node src/package-resolutions-updater.mjs [options]
+Options:
+  --help, -h           Show this help message
+Description:
+  Updates the commit hashes in package.json's 'resolutions' field for GitHub tarball URLs to point to the latest commit SHA of the corresponding repository and branch.
+Features:
+  - Parses GitHub URLs to extract repository owner, name, and branch.
+  - Fetches the latest commit SHA across all branches using GitHub's API.
+  - Replaces the old branch or commit in the URL with the latest SHA.
+  - Overwrites package.json with the updated URLs.
+Requirements:
+  - GitHub Personal Access Token (GITHUB_TOKEN) via .env
+  - ESM support (type: "module" in package.json)
+  - Node.js v18+ recommended
+Dependencies:
+  - ansi-colors \u2013 for styled terminal output
+  - dotenv \u2013 to load GitHub token from .env
+Examples:
+  node src/package-resolutions-updater.mjs
+  node src/package-resolutions-updater.mjs --help
+
+`;
+  console.log(helpText);
+  process.exit(0);
+}
+var GITHUB_USER_AGENTS = [
+  "octokit-rest.js/19.0.7",
+  "GitHub CLI/2.40.0",
+  "Mozilla/5.0 (compatible; GitHubCopilot/1.0)",
+  "PostmanRuntime/7.32.3",
+  "binary-collections-resolver/1.0 (+https://github.com/dimaslanjaka/bin)"
+];
+var userAgentDir = path.join(os.tmpdir(), "nodejs");
+var userAgentFile = path.join(userAgentDir, "useragent.txt");
+var selectedUserAgent;
+try {
+  if (!fs.existsSync(userAgentDir)) fs.mkdirSync(userAgentDir, { recursive: true });
+  if (fs.existsSync(userAgentFile)) {
+    const fileAgent = fs.readFileSync(userAgentFile, "utf-8").trim();
+    if (GITHUB_USER_AGENTS.includes(fileAgent)) {
+      selectedUserAgent = fileAgent;
+    }
+  }
+  if (!selectedUserAgent) {
+    selectedUserAgent = GITHUB_USER_AGENTS[Math.floor(Math.random() * GITHUB_USER_AGENTS.length)];
+    fs.writeFileSync(userAgentFile, selectedUserAgent, "utf-8");
+  }
+} catch (_e) {
+  selectedUserAgent = GITHUB_USER_AGENTS[Math.floor(Math.random() * GITHUB_USER_AGENTS.length)];
+}
+function fetchJson(url) {
+  const headers = {
+    "User-Agent": selectedUserAgent,
+    Accept: "application/vnd.github.v3+json",
+    "X-GitHub-Api-Version": "2022-11-28",
+    ...ACCESS_TOKEN ? { Authorization: `token ${ACCESS_TOKEN}` } : {}
+  };
+  return new Promise((resolve, reject) => {
+    https.get(url, { headers }, (res) => {
+      let data = "";
+      res.on("data", (chunk) => data += chunk);
+      res.on("end", () => {
+        try {
+          const json = JSON.parse(data);
+          if (res.statusCode < 200 || res.statusCode >= 300) {
+            return reject(
+              new Error(`GitHub API Error ${res.statusCode}: ${json.message || "Unknown error"}
+URL: ${url}`)
+            );
+          }
+          resolve(json);
+        } catch {
+          reject(new Error(`Invalid JSON from: ${url}`));
+        }
+      });
+    }).on("error", reject);
+  });
+}
+async function getLatestCommit(owner, repo, branch = "main") {
+  var _a, _b, _c, _d;
+  const url = `https://api.github.com/repos/${owner}/${repo}/commits/${branch}`;
+  const json = await fetchJson(url);
+  const sha = json.sha;
+  const dateStr = ((_b = (_a = json.commit) == null ? void 0 : _a.committer) == null ? void 0 : _b.date) || ((_d = (_c = json.commit) == null ? void 0 : _c.author) == null ? void 0 : _d.date);
+  if (!sha || !dateStr) {
+    console.log(json);
+    throw new Error(`Missing SHA or date for ${owner}/${repo}@${branch}`);
+  }
+  return {
+    owner,
+    repo,
+    branch,
+    sha,
+    date: new Date(dateStr).toISOString()
+  };
+}
+async function getLatestCommitAcrossBranches(owner, repo) {
+  const branches = await fetchJson(`https://api.github.com/repos/${owner}/${repo}/branches`);
+  const commits = await Promise.all(
+    branches.map(async ({ name, commit }) => {
+      var _a, _b, _c, _d;
+      const commitSha = commit == null ? void 0 : commit.sha;
+      if (!commitSha) {
+        console.warn(`No commit SHA for '${owner}/${repo}' branch: ${name}`);
+        return { branch: name, sha: "", date: /* @__PURE__ */ new Date(0) };
+      }
+      try {
+        const commitData = await fetchJson(`https://api.github.com/repos/${owner}/${repo}/commits/${commitSha}`);
+        const dateStr = ((_b = (_a = commitData.commit) == null ? void 0 : _a.committer) == null ? void 0 : _b.date) || ((_d = (_c = commitData.commit) == null ? void 0 : _c.author) == null ? void 0 : _d.date);
+        const date = dateStr ? new Date(dateStr) : /* @__PURE__ */ new Date(0);
+        return { branch: name, sha: commitData.sha, date };
+      } catch (e) {
+        console.warn(`Failed to fetch commit for ${name}: ${e.message}`);
+        return { branch: name, sha: commitSha, date: /* @__PURE__ */ new Date(0) };
+      }
+    })
+  );
+  const latest = commits.reduce((a, b) => a.date > b.date ? a : b, { date: /* @__PURE__ */ new Date(0) });
+  return {
+    owner,
+    repo,
+    branch: latest.branch,
+    sha: latest.sha,
+    date: latest.date.toISOString()
+  };
+}
+function replaceRawWithLatestHash(url, latestHash) {
+  const parsed = parseGitHubUrl(url);
+  if (!parsed || !parsed.owner || !parsed.repo || !parsed.branch) {
+    throw new Error("Invalid GitHub raw URL");
+  }
+  const branchPrefix = `${parsed.branch}/`;
+  const rawPrefix = parsed.host === "github.com" ? `raw/${branchPrefix}` : branchPrefix;
+  const refsPrefix = `refs/heads/${branchPrefix}`;
+  const path2 = parsed.path.startsWith(rawPrefix) ? parsed.path.slice(rawPrefix.length) : parsed.path.startsWith(refsPrefix) ? parsed.path.slice(refsPrefix.length) : parsed.path.startsWith(branchPrefix) ? parsed.path.slice(branchPrefix.length) : parsed.path;
+  if (parsed.host === "github.com") {
+    return `https://github.com/${parsed.owner}/${parsed.repo}/raw/${latestHash}/${path2}`;
+  }
+  if (parsed.host === "raw.githubusercontent.com") {
+    return `https://raw.githubusercontent.com/${parsed.owner}/${parsed.repo}/${latestHash}/${path2}`;
+  }
+  throw new Error("Invalid GitHub raw URL");
+}
+async function resolvePackageResolutionUpdates(resolutions, specialPackageOverrides = []) {
+  const updates = [];
+  for (const [currentPkgName, url] of Object.entries(resolutions || {})) {
+    let repo;
+    try {
+      repo = parseGitHubUrl(url);
+    } catch (error) {
+      updates.push({
+        skipped: true,
+        currentPkgName,
+        url,
+        error
+      });
+      continue;
+    }
+    try {
+      const override = specialPackageOverrides.find((p) => p.pkg === currentPkgName);
+      const latest = override ? await getLatestCommit(override.owner, override.repo, override.branch) : await getLatestCommitAcrossBranches(repo.owner, repo.repo);
+      const new_url = replaceRawWithLatestHash(url, latest.sha);
+      await axios.head(new_url, {
+        headers: {
+          "User-Agent": selectedUserAgent,
+          Accept: "application/vnd.github.v3+json",
+          "X-GitHub-Api-Version": "2022-11-28",
+          ...ACCESS_TOKEN ? { Authorization: `token ${ACCESS_TOKEN}` } : {}
+        }
+      }).then((response) => {
+        if (response.status < 200 || response.status >= 300) {
+          updates.push({
+            failed: true,
+            currentPkgName,
+            url,
+            new_url,
+            repo,
+            latest,
+            error: new Error(`New URL is not accessible, status code: ${response.status}`)
+          });
+          return;
+        }
+        updates.push({
+          currentPkgName,
+          url,
+          new_url,
+          repo,
+          latest
+        });
+      }).catch((e) => {
+        updates.push({
+          failed: true,
+          currentPkgName,
+          url,
+          new_url,
+          repo,
+          latest,
+          error: new Error(`New URL is not accessible: ${e.message}`)
+        });
+        return null;
+      });
+    } catch (error) {
+      updates.push({
+        failed: true,
+        currentPkgName,
+        url,
+        repo,
+        error
+      });
+    }
+  }
+  return updates;
+}
+
+export {
+  parseGitHubUrl,
+  fetchJson,
+  getLatestCommit,
+  getLatestCommitAcrossBranches,
+  replaceRawWithLatestHash,
+  resolvePackageResolutionUpdates
+};

package/lib/chunk-6PU7BAHB.mjs

@@ -0,0 +1,61 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  require_package
+} from "./chunk-ZOWVMII3.mjs";
+import {
+  __commonJS,
+  __dirname,
+  __require,
+  init_esm_shims
+} from "./chunk-QQ4A6DLD.mjs";
+
+// src/binary-collections/listScript.cjs
+var require_listScript = __commonJS({
+  "src/binary-collections/listScript.cjs"(exports, module) {
+    init_esm_shims();
+    var pkgJson = require_package();
+    var path = __require("upath");
+    var fs = __require("fs-extra");
+    function listScript(verbose = false) {
+      const keys = Object.keys(pkgJson.bin);
+      const results = [];
+      for (const scriptName of keys) {
+        if (verbose) {
+          console.log(`\u{1F50D} Finding script "${scriptName}" -> "${pkgJson.bin[scriptName]}"`);
+        }
+        const searchDirs = [
+          path.join(__dirname, ".."),
+          path.join(__dirname, "../.."),
+          path.join(process.cwd(), "node_modules/binary-collections"),
+          __dirname
+        ];
+        let scriptPath;
+        for (const searchDir of searchDirs) {
+          scriptPath = path.join(searchDir, pkgJson.bin[scriptName]);
+          if (fs.existsSync(scriptPath)) {
+            break;
+          }
+        }
+        if (!fs.existsSync(scriptPath)) {
+          console.warn(`\u26A0\uFE0F  Script "${scriptName}" defined in package.json not found at ${scriptPath}`);
+        } else {
+          if (verbose) {
+            console.log(`\u2705 Found script "${scriptName}" at ${scriptPath}`);
+          }
+          results.push({
+            name: scriptName,
+            path: path.relative(process.cwd(), scriptPath),
+            absolutePath: path.resolve(scriptPath)
+          });
+        }
+      }
+      return results;
+    }
+    module.exports = listScript;
+    module.exports.default = listScript;
+  }
+});
+
+export {
+  require_listScript
+};

package/lib/{chunk-6HHJRKFB.mjs → chunk-BZWVHODJ.mjs}

@@ -13,7 +13,10 @@ var require_submodule_remove = __commonJS({
     var path = __require("upath");
     var fs = __require("fs-extra");
     var dotenv = __require("dotenv");
-    dotenv.config({ path: path.resolve(process.cwd(), ".env") });
+    var envPath = path.resolve(process.cwd(), ".env");
+    if (fs.existsSync(envPath)) {
+      dotenv.config({ path: envPath, override: true, quiet: true });
+    }
     async function removeSubmodule(submodulePath) {
       try {
         await spawnAsync("git", ["submodule", "deinit", "-f", submodulePath], { stdio: "inherit" });

package/lib/chunk-C6D2TTYU.mjs

@@ -0,0 +1,32 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  isWindows
+} from "./chunk-XPJGCDOD.mjs";
+import {
+  init_esm_shims
+} from "./chunk-QQ4A6DLD.mjs";
+
+// src/cross-env/command.ts
+init_esm_shims();
+import path from "path";
+function commandConvert(command, env, normalize = false) {
+  if (!isWindows()) {
+    return command;
+  }
+  const simpleEnvRegex = /\$(\w+)|\${(\w+)}/g;
+  const defaultValueRegex = /\$\{(\w+):-([^}]+)\}/g;
+  let convertedCmd = command;
+  convertedCmd = convertedCmd.replace(defaultValueRegex, (match, varName, defaultValue) => {
+    const value = env[varName] || defaultValue;
+    return value;
+  });
+  convertedCmd = convertedCmd.replace(simpleEnvRegex, (match, $1, $2) => {
+    const varName = $1 || $2;
+    return env[varName] ? `%${varName}%` : "";
+  });
+  return normalize === true ? path.normalize(convertedCmd) : convertedCmd;
+}
+
+export {
+  commandConvert
+};

package/lib/chunk-FB2WKVJD.mjs

@@ -0,0 +1,158 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  require_findEnvFiles
+} from "./chunk-H44UWUFY.mjs";
+import {
+  __commonJS,
+  __require,
+  init_esm_shims
+} from "./chunk-QQ4A6DLD.mjs";
+
+// src/clean-github-actions-caches.cjs
+var require_clean_github_actions_caches = __commonJS({
+  "src/clean-github-actions-caches.cjs"(exports, module) {
+    init_esm_shims();
+    var axios = __require("axios");
+    var minimist = __require("minimist");
+    var { findEnvWithToken } = require_findEnvFiles();
+    __require("dotenv").config({
+      path: findEnvWithToken(),
+      quiet: true,
+      overwrite: true
+    });
+    var ACCESS_TOKEN = process.env.GITHUB_TOKEN || process.env.ACCESS_TOKEN;
+    if (!ACCESS_TOKEN) {
+      throw new Error(
+        "Access token is not provided. Please set ACCESS_TOKEN or GITHUB_TOKEN in your environment variables."
+      );
+    }
+    function printHelp() {
+      console.log(`
+GitHub Actions Cache Cleaner
+
+Description:
+  Removes outdated GitHub Actions caches for a repository, keeping only the newest
+  cache for each cache-key prefix. Authenticates via ACCESS_TOKEN or GITHUB_TOKEN
+  from your environment or .env file.
+
+Usage:
+  clean-github-actions-caches [options]
+
+Options:
+  -h, --help           Show this help message
+  -r, --repo <repo>    GitHub repository (owner/repo). If omitted, the tool will
+                       attempt to infer the repository from the current working
+                       directory's git remotes.
+
+Environment Variables:
+  ACCESS_TOKEN         GitHub access token (preferred)
+  GITHUB_TOKEN         GitHub access token (fallback)
+
+Behavior & Safety:
+  - Groups caches by a derived prefix from the cache key and keeps the most
+    recently created cache for each group.
+  - Deletes only caches older than the latest per prefix to reduce risk of
+    removing needed artifacts.
+
+Examples:
+  # Run against a specific repo (owner/repo)
+  clean-github-actions-caches --repo octocat/hello-world
+
+  # Run via npx without installing
+  npx -y binary-collections@https://raw.githubusercontent.com/dimaslanjaka/bin/master/releases/bin.tgz clean-github-actions-caches --repo owner/repo
+
+  # Run via yarn dlx
+  yarn dlx binary-collections@https://raw.githubusercontent.com/dimaslanjaka/bin/master/releases/bin.tgz clean-github-actions-caches
+
+Notes:
+  - Ensure ACCESS_TOKEN or GITHUB_TOKEN is set and has permissions to manage Actions caches.
+  - Intended for repository maintainers with appropriate permissions.
+`);
+    }
+    var argv = minimist(process.argv.slice(2), {
+      alias: {
+        h: "help",
+        r: "repo"
+      },
+      string: ["repo"],
+      boolean: ["help"]
+    });
+    if (argv.help) {
+      printHelp();
+      process.exit(0);
+    }
+    function deleteGitHubActionsCache(GH_REPO, cacheId) {
+      return new Promise((resolve, reject) => {
+        const url = `https://api.github.com/repos/${GH_REPO}/actions/caches/${cacheId}`;
+        const token = ACCESS_TOKEN;
+        if (!token) {
+          return reject(new Error("Access token is not provided"));
+        }
+        axios.delete(url, {
+          headers: {
+            Authorization: `token ${token}`,
+            Accept: "application/vnd.github.v3+json"
+          }
+        }).then((response) => {
+          console.log(`Cache (${cacheId}) deleted successfully`, response.data);
+          resolve(response.data);
+        }).catch((error) => {
+          var _a;
+          console.error("Error deleting cache:", ((_a = error.response) == null ? void 0 : _a.data) || error.message || "Unknown error");
+          reject(error);
+        });
+      });
+    }
+    function get_caches(GH_REPO) {
+      const url = `https://api.github.com/repos/${GH_REPO}/actions/caches`;
+      return new Promise((resolve, reject) => {
+        axios.get(url, {
+          headers: {
+            Accept: "application/vnd.github.v3+json",
+            Authorization: `token ${ACCESS_TOKEN}`
+          }
+        }).then((response) => {
+          const data = response.data.actions_caches;
+          const getPrefix = (key) => {
+            const split = key.split(/[-_]/);
+            if (split.length === 3) {
+              return `${split[0]}-${split[1]}`;
+            }
+            if (split.length > 3) {
+              return `${split[0]}-${split[1]}-${split[2]}`;
+            }
+            return split[0];
+          };
+          const grouped = data.reduce(
+            /**
+             * @param {Record<string, Record<string, any>[]>} acc
+             * @param {Record<string, any>} item
+             * @returns {Record<string, Record<string, any>[]>}
+             */
+            (acc, item) => {
+              const prefix = getPrefix(item.key);
+              if (!acc[prefix]) {
+                acc[prefix] = [];
+              }
+              acc[prefix].push(item);
+              return acc;
+            },
+            {}
+          );
+          resolve(grouped);
+        }).catch((error) => {
+          console.error("Error fetching data:", error);
+          reject(error);
+        });
+      });
+    }
+    module.exports = {
+      deleteGitHubActionsCache,
+      get_caches
+    };
+  }
+});
+
+export {
+  require_clean_github_actions_caches
+};

package/lib/{chunk-66PAU5PS.mjs → chunk-G5UUEWUO.mjs}

@@ -1,16 +1,20 @@
 import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  require_findEnvFiles
+} from "./chunk-H44UWUFY.mjs";
 import {
   __commonJS,
   __require,
   init_esm_shims
 } from "./chunk-QQ4A6DLD.mjs";
 
-// src/binary-collections-config.cjs
-var require_binary_collections_config = __commonJS({
-  "src/binary-collections-config.cjs"(exports, module) {
+// src/binary-collections/config.cjs
+var require_config = __commonJS({
+  "src/binary-collections/config.cjs"(exports, module) {
     init_esm_shims();
     var path = __require("path");
-    __require("dotenv").config({ path: path.join(process.cwd(), ".env") });
+    var { findEnvWithToken } = require_findEnvFiles();
+    __require("dotenv").config({ path: findEnvWithToken(), quiet: true, overwrite: true });
     function getTempDir() {
       return process.env.TEMP_DIR || path.join(process.cwd(), "tmp");
     }
@@ -27,5 +31,5 @@ var require_binary_collections_config = __commonJS({
 });
 
 export {
-  require_binary_collections_config
+  require_config
 };