binary-collections 2.0.13 → 2.0.15

package/lib/github-workflows/utils.cjs

@@ -0,0 +1,279 @@
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+
+// node_modules/tsup/assets/cjs_shims.js
+var init_cjs_shims = __esm({
+  "node_modules/tsup/assets/cjs_shims.js"() {
+  }
+});
+
+// src/utils/findEnvFiles.cjs
+var require_findEnvFiles = __commonJS({
+  "src/utils/findEnvFiles.cjs"(exports2, module2) {
+    init_cjs_shims();
+    var fs = require("fs");
+    var path = require("path");
+    var glob = require("glob");
+    var DEFAULT_IGNORES = [
+      "**/node_modules/**",
+      "**/.git/**",
+      "**/.yarn/**",
+      "**/.pnpm/**",
+      "**/dist/**",
+      "**/build/**",
+      "**/coverage/**",
+      "**/vendor/**",
+      "**/tmp/**",
+      "**/.cache/**",
+      "**/assets/**",
+      "**/logs/**",
+      "**/output/**",
+      "**/public/**",
+      "**/static/**",
+      "**/temp/**",
+      "**/backup/**",
+      "**/backups/**",
+      "**/examples/**",
+      "**/docs/**",
+      "**/tests/**",
+      "**/__tests__/**",
+      "**/spec/**",
+      "**/__specs__/**",
+      "**/scripts/**",
+      "**/bin/**",
+      "**/hooks/**",
+      "**/config/**",
+      "**/configs/**",
+      "**/settings/**",
+      "**/.vscode/**",
+      "**/.idea/**"
+    ];
+    function findEnvFiles(startDir = process.cwd(), filter) {
+      const found = /* @__PURE__ */ new Set();
+      function addFile(file) {
+        const normalized = path.normalize(file);
+        if (typeof filter === "function" && !filter(normalized)) {
+          return;
+        }
+        found.add(normalized);
+      }
+      let current = path.resolve(startDir);
+      while (true) {
+        const envPath = path.join(current, ".env");
+        if (fs.existsSync(envPath)) {
+          addFile(envPath);
+        }
+        const parent = path.dirname(current);
+        if (parent === current) {
+          break;
+        }
+        current = parent;
+      }
+      const files = glob.globSync("**/.env*", {
+        cwd: startDir,
+        absolute: true,
+        nodir: true,
+        ignore: DEFAULT_IGNORES
+      });
+      for (const file of files) {
+        addFile(file);
+      }
+      return [...found];
+    }
+    function findEnvWithToken(startDir = process.cwd(), tokenName = "GITHUB_TOKEN") {
+      const envFiles = findEnvFiles(startDir);
+      return envFiles.find((file) => {
+        try {
+          const content = fs.readFileSync(file, "utf-8");
+          if (tokenName instanceof RegExp) {
+            return tokenName.test(content);
+          }
+          const regex = new RegExp(`^\\s*${tokenName}\\s*=`, "m");
+          return regex.test(content);
+        } catch (err) {
+          console.warn(`Failed to read ${file}: ${err instanceof Error ? err.message : String(err)}`);
+          return false;
+        }
+      });
+    }
+    module2.exports = {
+      DEFAULT_IGNORES,
+      findEnvFiles,
+      findEnvWithToken,
+      default: findEnvFiles
+    };
+  }
+});
+
+// src/binary-collections/config.cjs
+var require_config = __commonJS({
+  "src/binary-collections/config.cjs"(exports2, module2) {
+    init_cjs_shims();
+    var path = require("upath");
+    var minimistLib = require("minimist");
+    var { findEnvWithToken } = require_findEnvFiles();
+    var dotenv = require("dotenv");
+    var { cosmiconfig } = require("cosmiconfig");
+    var loadDotenv = (tokenKey = /ACCESS_TOKEN|GITHUB_TOKEN/) => dotenv.config({ path: findEnvWithToken(void 0, tokenKey), quiet: true, overwrite: true });
+    loadDotenv();
+    var cliArgv = minimistLib(process.argv.slice(2), {
+      string: ["token"]
+    });
+    var GITHUB_ACCESS_TOKEN = cliArgv.token || process.env.ACCESS_TOKEN || process.env.GITHUB_TOKEN || process.env.GH_TOKEN;
+    function getTempPath(...segments) {
+      return path.join(process.env.TEMP_DIR || path.join(process.cwd(), "tmp"), ...segments);
+    }
+    async function getConfig(options = {}) {
+      const explorer = cosmiconfig("binary-collections", {
+        searchStrategy: "project",
+        stopDir: options.stopDir
+      });
+      try {
+        const result = await explorer.search(options.searchFrom);
+        return result ? result.config : null;
+      } catch {
+        return null;
+      }
+    }
+    module2.exports = {
+      getTempPath,
+      GITHUB_ACCESS_TOKEN,
+      loadDotenv,
+      getConfig
+    };
+  }
+});
+
+// src/github-workflows/utils.cjs
+init_cjs_shims();
+var axios = require("axios");
+var { spawn } = require("cross-spawn");
+var { GITHUB_ACCESS_TOKEN: TOKEN } = require_config();
+if (!TOKEN) {
+  console.error("Missing env var: ACCESS_TOKEN or GITHUB_TOKEN");
+  process.exit(1);
+}
+var BASE = "https://api.github.com";
+var HEADERS = {
+  Authorization: `Bearer ${TOKEN}`,
+  Accept: "application/vnd.github+json",
+  "X-GitHub-Api-Version": "2022-11-28"
+};
+async function request(url) {
+  try {
+    const res = await axios.get(url, { headers: HEADERS });
+    return res.data;
+  } catch (err) {
+    if (err == null ? void 0 : err.response) {
+      const statusText = err.response.statusText || "Request failed";
+      const responseText = typeof err.response.data === "string" ? err.response.data : JSON.stringify(err.response.data);
+      throw new Error(`${err.response.status} ${statusText}
+${responseText}`);
+    }
+    throw err;
+  }
+}
+function runGit(args) {
+  return new Promise((resolve, reject) => {
+    var _a, _b;
+    const child = spawn("git", args, {
+      cwd: process.cwd(),
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    (_a = child.stdout) == null ? void 0 : _a.on("data", (chunk) => {
+      stdout += chunk.toString();
+    });
+    (_b = child.stderr) == null ? void 0 : _b.on("data", (chunk) => {
+      stderr += chunk.toString();
+    });
+    child.on("error", reject);
+    child.on("close", (code) => {
+      if (code === 0) return resolve(stdout.trim());
+      reject(new Error(stderr.trim() || `git ${args.join(" ")} exited with code ${code}`));
+    });
+  });
+}
+function parseOwnerFromUrl(remoteUrl) {
+  const normalized = remoteUrl.trim().replace(/\.git$/i, "");
+  const match = normalized.match(/github\.com[:/](?<owner>[^/]+)\/(?<repo>[^/]+)$/i);
+  return (match == null ? void 0 : match.groups) || null;
+}
+function getOwnerFromRemoteUrl(remoteUrl) {
+  const parsed = parseOwnerFromUrl(remoteUrl);
+  return (parsed == null ? void 0 : parsed.owner) || null;
+}
+function getRepoFromRemoteUrl(remoteUrl) {
+  const parsed = parseOwnerFromUrl(remoteUrl);
+  return (parsed == null ? void 0 : parsed.repo) || null;
+}
+async function getCurrentOwner() {
+  const commands = [
+    ["config", "--local", "--get", "remote.origin.url"],
+    ["remote", "get-url", "origin"]
+  ];
+  for (const args of commands) {
+    try {
+      const remoteUrl = await runGit(args);
+      const owner = getOwnerFromRemoteUrl(remoteUrl);
+      if (owner) return owner;
+    } catch {
+    }
+  }
+  throw new Error("Unable to determine repository owner from git remote.origin.url");
+}
+async function getCurrentRepo() {
+  const commands = [
+    ["config", "--local", "--get", "remote.origin.url"],
+    ["remote", "get-url", "origin"]
+  ];
+  for (const args of commands) {
+    try {
+      const remoteUrl = await runGit(args);
+      const repo = getRepoFromRemoteUrl(remoteUrl);
+      if (repo) return repo;
+    } catch {
+    }
+  }
+  throw new Error("Unable to determine repository name from git remote.origin.url");
+}
+async function getOwnerRepo() {
+  const owner = await getCurrentOwner();
+  const repo = await getCurrentRepo();
+  return { owner, repo };
+}
+async function getLatestRun(owner, repo, workflowId) {
+  var _a;
+  let url;
+  if (workflowId) {
+    url = `${BASE}/repos/${owner}/${repo}/actions/workflows/${encodeURIComponent(workflowId)}/runs?per_page=1`;
+  } else {
+    url = `${BASE}/repos/${owner}/${repo}/actions/runs?per_page=1`;
+  }
+  const data = await request(url);
+  return (_a = data.workflow_runs) == null ? void 0 : _a[0];
+}
+async function getJobs(owner, repo, runId) {
+  const data = await request(`${BASE}/repos/${owner}/${repo}/actions/runs/${runId}/jobs`);
+  return data.jobs || [];
+}
+module.exports = {
+  BASE,
+  HEADERS,
+  request,
+  runGit,
+  parseOwnerFromUrl,
+  getOwnerFromRemoteUrl,
+  getRepoFromRemoteUrl,
+  getCurrentOwner,
+  getCurrentRepo,
+  getOwnerRepo,
+  getLatestRun,
+  getJobs
+};

package/lib/github-workflows/utils.d.cts

@@ -0,0 +1,76 @@
+export const BASE: "https://api.github.com";
+export const HEADERS: {
+    Authorization: string;
+    Accept: string;
+    'X-GitHub-Api-Version': string;
+};
+/**
+ * Make a GET request to the GitHub REST API.
+ * @param {string} url - Full URL to fetch
+ * @returns {Promise<object>} Response JSON body
+ */
+export function request(url: string): Promise<object>;
+/**
+ * Run a git command and return stdout.
+ * @param {string[]} args - Arguments to pass to git
+ * @returns {Promise<string>} Trimmed stdout
+ */
+export function runGit(args: string[]): Promise<string>;
+/**
+ * Parse owner and repo from a GitHub remote URL.
+ * @param {string} remoteUrl - e.g. "git@github.com:owner/repo.git"
+ * @returns {{owner: string, repo: string}|null} Parsed groups or null
+ */
+export function parseOwnerFromUrl(remoteUrl: string): {
+    owner: string;
+    repo: string;
+} | null;
+/**
+ * Extract the owner from a GitHub remote URL.
+ * @param {string} remoteUrl
+ * @returns {string|null}
+ */
+export function getOwnerFromRemoteUrl(remoteUrl: string): string | null;
+/**
+ * Extract the repo name from a GitHub remote URL.
+ * @param {string} remoteUrl
+ * @returns {string|null}
+ */
+export function getRepoFromRemoteUrl(remoteUrl: string): string | null;
+/**
+ * Determine the repository owner from the local git remote.
+ * Tries multiple git command variants.
+ * @returns {Promise<string>}
+ */
+export function getCurrentOwner(): Promise<string>;
+/**
+ * Determine the repository name from the local git remote.
+ * Tries multiple git command variants.
+ * @returns {Promise<string>}
+ */
+export function getCurrentRepo(): Promise<string>;
+/**
+ * Get both owner and repo from the local git remote.
+ * @returns {Promise<{owner: string, repo: string}>}
+ */
+export function getOwnerRepo(): Promise<{
+    owner: string;
+    repo: string;
+}>;
+/**
+ * Get the latest workflow run for a repository.
+ * When workflowId is provided, filters by that specific workflow (filename or ID).
+ * @param {string} owner - GitHub repository owner
+ * @param {string} repo - GitHub repository name
+ * @param {string} [workflowId] - Workflow filename (e.g. "test.yml") or numeric ID
+ * @returns {Promise<object|undefined>} The latest workflow run object
+ */
+export function getLatestRun(owner: string, repo: string, workflowId?: string): Promise<object | undefined>;
+/**
+ * Get all jobs for a specific workflow run.
+ * @param {string} owner - GitHub repository owner
+ * @param {string} repo - GitHub repository name
+ * @param {number|string} runId - Workflow run ID
+ * @returns {Promise<object[]>} Array of job objects
+ */
+export function getJobs(owner: string, repo: string, runId: number | string): Promise<object[]>;

package/lib/github-workflows/utils.mjs

@@ -0,0 +1,8 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  require_utils
+} from "../chunk-DPEE3FBB.mjs";
+import "../chunk-3T6AMFI3.mjs";
+import "../chunk-J4M5EL5P.mjs";
+import "../chunk-QQ4A6DLD.mjs";
+export default require_utils();