@stacksjs/github 0.70.57 → 0.70.58

package/dist/bots.js

@@ -0,0 +1,21 @@
+import { ghFetch, GITHUB_API } from "./client";
+export async function fetchBotPRCounts(org, authorSlug) {
+  const counts = new Map;
+  let page = 1;
+  while (!0) {
+    const q = `is:pr is:open org:${org} author:app/${authorSlug}`, res = await ghFetch(`${GITHUB_API}/search/issues?q=${encodeURIComponent(q)}&per_page=100&page=${page}`);
+    if (!res.ok)
+      break;
+    const data = await res.json();
+    if (!data.items || data.items.length === 0)
+      break;
+    for (const item of data.items) {
+      const fullName = item.repository_url.replace(`${GITHUB_API}/repos/`, "");
+      counts.set(fullName, (counts.get(fullName) ?? 0) + 1);
+    }
+    if (data.items.length < 100)
+      break;
+    page++;
+  }
+  return counts;
+}

package/dist/client.js

@@ -0,0 +1,43 @@
+export const GITHUB_API = "https://api.github.com";
+function getToken() {
+  const token = process.env.GITHUB_TOKEN;
+  if (!token)
+    throw Error("GITHUB_TOKEN environment variable is required");
+  return token;
+}
+export function ghHeaders() {
+  return {
+    Authorization: `Bearer ${getToken()}`,
+    Accept: "application/vnd.github+json",
+    "X-GitHub-Api-Version": "2022-11-28"
+  };
+}
+export async function ghFetch(url, attempt = 0) {
+  const res = await fetch(url, { headers: ghHeaders() });
+  if (res.ok || attempt >= 3)
+    return res;
+  if (!(res.status === 429 || res.status === 403 && (res.headers.get("x-ratelimit-remaining") === "0" || res.headers.get("retry-after"))))
+    return res;
+  const retryAfterHeader = res.headers.get("retry-after"), resetHeader = res.headers.get("x-ratelimit-reset");
+  let waitMs = 1000 * 2 ** attempt;
+  if (retryAfterHeader)
+    waitMs = Number(retryAfterHeader) * 1000;
+  else if (resetHeader)
+    waitMs = Math.max(0, Number(resetHeader) * 1000 - Date.now()) + 500;
+  await new Promise((r) => setTimeout(r, Math.min(waitMs, 30000)));
+  return ghFetch(url, attempt + 1);
+}
+export async function mapWithConcurrency(items, limit, fn) {
+  const results = Array.from({ length: items.length });
+  let next = 0;
+  async function worker() {
+    while (!0) {
+      const i = next++;
+      if (i >= items.length)
+        return;
+      results[i] = await fn(items[i]);
+    }
+  }
+  await Promise.all(Array.from({ length: Math.min(limit, items.length) }, () => worker()));
+  return results;
+}

package/dist/dashboard.js

@@ -0,0 +1,110 @@
+import { fetchBotPRCounts } from "./bots";
+import { mapWithConcurrency } from "./client";
+import { fetchAllRepos } from "./repos";
+import { fetchRepoActiveRuns } from "./runners";
+import { fetchRepoStatus } from "./runs";
+const DEFAULT_TTL_MS = 30000, DEFAULT_CACHE_PATH = ".cache/dashboard.json", DEFAULT_RUNNER_CAP = 20, caches = new Map;
+function entryFor(path) {
+  let e = caches.get(path);
+  if (!e) {
+    e = { data: null, savedAt: 0, inflight: null, diskLoaded: !1 };
+    caches.set(path, e);
+  }
+  return e;
+}
+async function loadCacheFromDisk(entry, path) {
+  if (entry.diskLoaded)
+    return;
+  entry.diskLoaded = !0;
+  try {
+    const file = Bun.file(path);
+    if (!await file.exists())
+      return;
+    const stored = await file.json();
+    entry.data = stored.data;
+    entry.savedAt = stored.savedAt;
+  } catch {}
+}
+async function saveCacheToDisk(path, data, savedAt) {
+  try {
+    await Bun.write(path, JSON.stringify({ data, savedAt }));
+  } catch (err) {
+    console.warn("[github/dashboard] cache write failed:", err);
+  }
+}
+async function buildDashboardData(opts) {
+  const orgs = opts.orgs, runnerCaps = opts.runnerCaps ?? {}, defaultRunnerCap = opts.defaultRunnerCap ?? DEFAULT_RUNNER_CAP, repos = await fetchAllRepos(orgs, opts.ignoreRepos), statuses = await mapWithConcurrency(repos, 8, (r) => fetchRepoStatus(r.owner, r.name, r.default_branch)), prCountMaps = await Promise.all(orgs.flatMap((org) => [
+    fetchBotPRCounts(org, "renovate").then((m) => ({ type: "renovate", map: m })),
+    fetchBotPRCounts(org, "github-actions").then((m) => ({ type: "actions", map: m }))
+  ])), renovateCounts = new Map, actionsCounts = new Map;
+  for (const { type, map } of prCountMaps) {
+    const target = type === "renovate" ? renovateCounts : actionsCounts;
+    for (const [k, v] of map)
+      target.set(k, (target.get(k) ?? 0) + v);
+  }
+  for (const s of statuses) {
+    const rCount = renovateCounts.get(s.fullName) ?? 0, aCount = actionsCounts.get(s.fullName) ?? 0;
+    s.renovatePRs = rCount;
+    s.actionsPRs = aCount;
+    if (rCount > 0)
+      s.renovatePRsUrl = `https://github.com/${s.fullName}/pulls?q=${encodeURIComponent("is:pr is:open author:app/renovate")}`;
+    if (aCount > 0)
+      s.actionsPRsUrl = `https://github.com/${s.fullName}/pulls?q=${encodeURIComponent("is:pr is:open author:app/github-actions")}`;
+  }
+  const runnerCounts = await mapWithConcurrency(repos, 8, async (r) => ({
+    owner: r.owner,
+    ...await fetchRepoActiveRuns(r.owner, r.name)
+  })), runners = {};
+  for (const org of orgs)
+    runners[org] = { running: 0, queued: 0, cap: runnerCaps[org] ?? defaultRunnerCap };
+  for (const c of runnerCounts) {
+    if (!runners[c.owner])
+      runners[c.owner] = { running: 0, queued: 0, cap: runnerCaps[c.owner] ?? defaultRunnerCap };
+    runners[c.owner].running += c.running;
+    runners[c.owner].queued += c.queued;
+  }
+  const order = { failure: 0, error: 1, pending: 2, success: 3, no_runs: 4 };
+  statuses.sort((a, b) => (order[a.status] ?? 5) - (order[b.status] ?? 5));
+  return {
+    repos: statuses,
+    fetchedAt: new Date().toISOString(),
+    total: statuses.length,
+    passing: statuses.filter((r) => r.status === "success").length,
+    failing: statuses.filter((r) => r.status === "failure" || r.status === "error").length,
+    pending: statuses.filter((r) => r.status === "pending").length,
+    noRuns: statuses.filter((r) => r.status === "no_runs").length,
+    runners
+  };
+}
+export async function getDashboardData(opts) {
+  const ttl = opts.cacheTtlMs ?? DEFAULT_TTL_MS, path = opts.cachePath ?? DEFAULT_CACHE_PATH, entry = entryFor(path);
+  await loadCacheFromDisk(entry, path);
+  const now = Date.now();
+  if (entry.data) {
+    if (now - entry.savedAt >= ttl && !entry.inflight) {
+      entry.inflight = buildDashboardData(opts).then(async (data) => {
+        entry.data = data;
+        entry.savedAt = Date.now();
+        await saveCacheToDisk(path, data, entry.savedAt);
+        return data;
+      }).finally(() => {
+        entry.inflight = null;
+      });
+      entry.inflight.catch((err) => console.warn("[github/dashboard] refresh failed:", err));
+    }
+    return entry.data;
+  }
+  if (!entry.inflight)
+    entry.inflight = buildDashboardData(opts).then(async (data) => {
+      entry.data = data;
+      entry.savedAt = Date.now();
+      await saveCacheToDisk(path, data, entry.savedAt);
+      return data;
+    }).finally(() => {
+      entry.inflight = null;
+    });
+  return entry.inflight;
+}
+export function clearDashboardCache(cachePath = DEFAULT_CACHE_PATH) {
+  caches.delete(cachePath);
+}

package/dist/failure-detector.js

@@ -0,0 +1,67 @@
+const DEFAULT_COOLDOWN_MS = 300000, FAILED_CONCLUSIONS = new Set([
+  "failure",
+  "error",
+  "timed_out",
+  "startup_failure"
+]);
+function isFailed(repo) {
+  if (repo.status === "failure" || repo.status === "error")
+    return !0;
+  if (repo.conclusion && FAILED_CONCLUSIONS.has(repo.conclusion))
+    return !0;
+  return !1;
+}
+function isInFlight(repo) {
+  return repo.status === "pending";
+}
+export function detectNewlyFailedRuns(snapshot, previousStates, options = {}) {
+  const cooldownMs = options.cooldownMs ?? DEFAULT_COOLDOWN_MS, now = options.now ?? Date.now(), transitions = [];
+  for (const repo of snapshot.repos) {
+    if (!isFailed(repo) || isInFlight(repo))
+      continue;
+    const prev = previousStates.get(repo.fullName);
+    if (prev?.lastConclusion ? FAILED_CONCLUSIONS.has(prev.lastConclusion) || prev.lastConclusion === "failure" || prev.lastConclusion === "error" : !1) {
+      const currentRunId = parseRunIdFromUrl(repo.runUrl);
+      if (currentRunId !== null && prev?.lastRunId !== null && currentRunId === prev?.lastRunId)
+        continue;
+      if (prev?.lastNotifiedAt && isWithinCooldown(prev.lastNotifiedAt, cooldownMs, now))
+        continue;
+      transitions.push(toTransition(repo, prev?.lastConclusion ?? null));
+      continue;
+    }
+    if (prev?.lastNotifiedAt && isWithinCooldown(prev.lastNotifiedAt, cooldownMs, now))
+      continue;
+    transitions.push(toTransition(repo, prev?.lastConclusion ?? null));
+  }
+  return transitions;
+}
+function isWithinCooldown(lastNotifiedAt, cooldownMs, now) {
+  if (cooldownMs === 0)
+    return !1;
+  const ts = Date.parse(lastNotifiedAt);
+  if (Number.isNaN(ts))
+    return !1;
+  return now - ts < cooldownMs;
+}
+function parseRunIdFromUrl(runUrl) {
+  if (!runUrl)
+    return null;
+  const match = runUrl.match(/\/actions\/runs\/(\d+)/);
+  if (!match)
+    return null;
+  const id = Number(match[1]);
+  return Number.isFinite(id) ? id : null;
+}
+function toTransition(repo, previousConclusion) {
+  return {
+    repoFullName: repo.fullName,
+    conclusion: repo.conclusion ?? repo.status,
+    runId: parseRunIdFromUrl(repo.runUrl),
+    workflowName: repo.workflowName,
+    commitSha: repo.commitSha,
+    commitMessage: repo.commitMessage,
+    commitAuthor: repo.commitAuthor,
+    runUrl: repo.runUrl,
+    previousConclusion
+  };
+}

package/dist/index.js

@@ -1,18 +1,9 @@
-// @bun
-export {
-  mapWithConcurrency,
-  ghHeaders,
-  ghFetch,
-  getDashboardData,
-  fetchWorkflowRuns,
-  fetchRunJobs,
-  fetchRepoStatus,
-  fetchRepoActiveRuns,
-  fetchFailedJobs,
-  fetchBotPRCounts,
-  fetchAllRepos,
-  detectRunnerPressure,
-  detectNewlyFailedRuns,
-  clearDashboardCache,
-  GITHUB_API
-};
+export { fetchBotPRCounts } from "./bots";
+export { ghFetch, ghHeaders, GITHUB_API, mapWithConcurrency } from "./client";
+export { clearDashboardCache, getDashboardData } from "./dashboard";
+export { detectNewlyFailedRuns } from "./failure-detector";
+export { fetchAllRepos } from "./repos";
+export { fetchRepoActiveRuns } from "./runners";
+export { fetchRunJobs, fetchWorkflowRuns } from "./run-history";
+export { detectRunnerPressure } from "./runner-pressure-detector";
+export { fetchFailedJobs, fetchRepoStatus } from "./runs";

package/dist/repos.js

@@ -0,0 +1,26 @@
+import { ghFetch, GITHUB_API } from "./client";
+export async function fetchAllRepos(orgs, ignore = [".github"]) {
+  const ignored = new Set(ignore), all = [];
+  for (const org of orgs) {
+    let page = 1;
+    while (!0) {
+      const res = await ghFetch(`${GITHUB_API}/orgs/${org}/repos?per_page=100&page=${page}&type=public`);
+      if (!res.ok)
+        break;
+      const repos = await res.json();
+      if (repos.length === 0)
+        break;
+      for (const repo of repos)
+        all.push({
+          name: repo.name,
+          owner: repo.owner.login,
+          full_name: repo.full_name,
+          html_url: repo.html_url,
+          default_branch: repo.default_branch,
+          archived: repo.archived
+        });
+      page++;
+    }
+  }
+  return all.filter((r) => !r.archived && !ignored.has(r.name));
+}

package/dist/run-history.js

@@ -0,0 +1,63 @@
+import { ghFetch, GITHUB_API } from "./client";
+function shortSha(sha) {
+  return sha.length > 7 ? sha.slice(0, 7) : sha;
+}
+function diffMs(start, end) {
+  if (!start || !end)
+    return null;
+  const s = Date.parse(start), e = Date.parse(end);
+  if (Number.isNaN(s) || Number.isNaN(e))
+    return null;
+  if (e < s)
+    return null;
+  return e - s;
+}
+export async function fetchWorkflowRuns(owner, name, options = {}) {
+  const limit = Math.max(1, Math.min(options.limit ?? 20, 100)), params = new URLSearchParams;
+  params.set("per_page", String(limit));
+  if (options.branch)
+    params.set("branch", options.branch);
+  if (options.event)
+    params.set("event", options.event);
+  const res = await ghFetch(`${GITHUB_API}/repos/${owner}/${name}/actions/runs?${params.toString()}`);
+  if (!res.ok)
+    return [];
+  return ((await res.json()).workflow_runs ?? []).map((r) => ({
+    id: r.id,
+    status: r.status,
+    conclusion: r.conclusion,
+    name: r.name,
+    headBranch: r.head_branch,
+    headSha: r.head_sha,
+    headShaShort: shortSha(r.head_sha),
+    commitMessage: r.head_commit?.message?.split(`
+`)[0] ?? null,
+    commitAuthor: r.head_commit?.author?.name ?? r.actor?.login ?? null,
+    event: r.event,
+    url: r.html_url,
+    startedAt: r.run_started_at ?? r.created_at ?? null,
+    updatedAt: r.updated_at,
+    durationMs: diffMs(r.run_started_at ?? r.created_at, r.updated_at)
+  }));
+}
+export async function fetchRunJobs(owner, name, runId) {
+  const res = await ghFetch(`${GITHUB_API}/repos/${owner}/${name}/actions/runs/${runId}/jobs?per_page=100`);
+  if (!res.ok)
+    return [];
+  return ((await res.json()).jobs ?? []).map((j) => ({
+    id: j.id,
+    name: j.name,
+    status: j.status,
+    conclusion: j.conclusion,
+    startedAt: j.started_at,
+    completedAt: j.completed_at,
+    durationMs: diffMs(j.started_at, j.completed_at),
+    url: j.html_url,
+    steps: (j.steps ?? []).map((s) => ({
+      name: s.name,
+      status: s.status,
+      conclusion: s.conclusion,
+      number: s.number
+    }))
+  }));
+}

package/dist/runner-pressure-detector.js

@@ -0,0 +1,27 @@
+export function detectRunnerPressure(samples, alertStates, options) {
+  const now = options.now ?? Date.now(), windowMs = options.windowMinutes * 60000, cutoffMs = now - windowMs, byOrg = new Map;
+  for (const s of samples) {
+    const t = Date.parse(s.sampledAt);
+    if (Number.isNaN(t) || t < cutoffMs)
+      continue;
+    const list = byOrg.get(s.org) ?? [];
+    list.push(s);
+    byOrg.set(s.org, list);
+  }
+  const actions = [];
+  for (const [org, orgSamples] of byOrg.entries()) {
+    if (orgSamples.length === 0)
+      continue;
+    orgSamples.sort((a, b) => Date.parse(a.sampledAt) - Date.parse(b.sampledAt));
+    const oldestMs = Date.parse(orgSamples[0].sampledAt), sustainedMs = Date.parse(orgSamples[orgSamples.length - 1].sampledAt) - oldestMs;
+    if (sustainedMs < windowMs - 1000)
+      continue;
+    const allAboveOrEqual = orgSamples.every((s) => s.queued >= options.queuedThreshold), allBelow = orgSamples.every((s) => s.queued < options.queuedThreshold), isAlerting = alertStates.get(org)?.alerting ?? !1, current = orgSamples[orgSamples.length - 1];
+    if (isAlerting) {
+      if (allBelow)
+        actions.push({ org, action: "clear", current, sustainedMs });
+    } else if (allAboveOrEqual)
+      actions.push({ org, action: "fire", current, sustainedMs });
+  }
+  return actions;
+}

package/dist/runners.js

@@ -0,0 +1,26 @@
+import { ghFetch, GITHUB_API } from "./client";
+export async function fetchRepoActiveRuns(owner, name) {
+  try {
+    const runRes = await ghFetch(`${GITHUB_API}/repos/${owner}/${name}/actions/runs?status=in_progress&per_page=100`);
+    if (!runRes.ok)
+      return { running: 0, queued: 0 };
+    const runs = (await runRes.json()).workflow_runs ?? [];
+    if (runs.length === 0)
+      return { running: 0, queued: 0 };
+    return (await Promise.all(runs.map(async (r) => {
+      const jobsRes = await ghFetch(`${GITHUB_API}/repos/${owner}/${name}/actions/runs/${r.id}/jobs`);
+      if (!jobsRes.ok)
+        return { running: 0, queued: 0 };
+      const jobsData = await jobsRes.json();
+      let running = 0, queued = 0;
+      for (const j of jobsData.jobs ?? [])
+        if (j.status === "in_progress")
+          running++;
+        else if (j.status === "queued")
+          queued++;
+      return { running, queued };
+    }))).reduce((a, b) => ({ running: a.running + b.running, queued: a.queued + b.queued }), { running: 0, queued: 0 });
+  } catch {
+    return { running: 0, queued: 0 };
+  }
+}

package/dist/runs.js

@@ -0,0 +1,86 @@
+import { ghFetch, GITHUB_API } from "./client";
+async function fillLatestCommit(base, owner, name, branch) {
+  try {
+    const res = await ghFetch(`${GITHUB_API}/repos/${owner}/${name}/commits?sha=${branch}&per_page=1`);
+    if (!res.ok)
+      return;
+    const commits = await res.json();
+    if (commits.length === 0)
+      return;
+    const c = commits[0];
+    base.commitSha = c.sha.slice(0, 7);
+    base.commitMessage = c.commit.message.split(`
+`)[0];
+    base.commitUrl = `https://github.com/${owner}/${name}/commit/${c.sha}`;
+    base.commitAuthor = c.commit.author?.name ?? c.author?.login ?? null;
+    base.updatedAt = c.commit.author?.date ?? null;
+  } catch {}
+}
+export async function fetchFailedJobs(owner, name, runId) {
+  try {
+    const res = await ghFetch(`${GITHUB_API}/repos/${owner}/${name}/actions/runs/${runId}/jobs?filter=latest`);
+    if (!res.ok)
+      return [];
+    return (await res.json()).jobs.filter((j) => j.conclusion && j.conclusion !== "success" && j.conclusion !== "skipped").map((j) => ({ name: j.name, conclusion: j.conclusion, url: j.html_url }));
+  } catch {
+    return [];
+  }
+}
+export async function fetchRepoStatus(owner, name, defaultBranch) {
+  const base = {
+    name,
+    owner,
+    fullName: `${owner}/${name}`,
+    url: `https://github.com/${owner}/${name}`,
+    defaultBranch,
+    status: "no_runs",
+    conclusion: null,
+    workflowName: null,
+    commitSha: null,
+    commitMessage: null,
+    commitUrl: null,
+    commitAuthor: null,
+    commitCount: null,
+    updatedAt: null,
+    runUrl: null,
+    failedJobs: [],
+    renovatePRs: 0,
+    renovatePRsUrl: null,
+    actionsPRs: 0,
+    actionsPRsUrl: null
+  };
+  try {
+    const res = await ghFetch(`${GITHUB_API}/repos/${owner}/${name}/actions/runs?branch=${defaultBranch}&event=push&per_page=1`);
+    if (!res.ok) {
+      base.status = "error";
+      await fillLatestCommit(base, owner, name, defaultBranch);
+      return base;
+    }
+    const data = await res.json();
+    if (!data.workflow_runs || data.workflow_runs.length === 0) {
+      await fillLatestCommit(base, owner, name, defaultBranch);
+      return base;
+    }
+    const run = data.workflow_runs[0];
+    base.workflowName = run.name;
+    base.commitSha = run.head_sha.slice(0, 7);
+    base.commitMessage = run.head_commit?.message.split(`
+`)[0] ?? null;
+    base.commitUrl = `https://github.com/${owner}/${name}/commit/${run.head_sha}`;
+    base.commitAuthor = run.head_commit?.author?.name ?? run.actor?.login ?? null;
+    base.updatedAt = run.updated_at;
+    base.runUrl = run.html_url;
+    if (run.status === "completed") {
+      base.status = run.conclusion === "success" ? "success" : "failure";
+      base.conclusion = run.conclusion;
+      if (base.status === "failure")
+        base.failedJobs = await fetchFailedJobs(owner, name, run.id);
+    } else {
+      base.status = "pending";
+      base.conclusion = run.status;
+    }
+  } catch {
+    base.status = "error";
+  }
+  return base;
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@stacksjs/github",
   "type": "module",
-  "version": "0.70.57",
+  "version": "0.70.58",
   "description": "GitHub API client used by Stacks framework features (dashboard CI surface, notifications, runner alerts).",
   "author": "Chris Breuer",
   "contributors": [