mirror of
https://github.com/different-ai/openwork
synced 2026-04-25 17:15:34 +02:00
336 lines
9.8 KiB
JavaScript
336 lines
9.8 KiB
JavaScript
#!/usr/bin/env node
|
|
|
|
import fs from "node:fs/promises"
|
|
import { resolve } from "node:path"
|
|
import { pathToFileURL } from "node:url"
|
|
|
|
const POSTHOG_KEY = process.env.POSTHOG_KEY || process.env.POSTHOG_API_KEY
|
|
const POSTHOG_HOST = process.env.POSTHOG_HOST || "https://us.i.posthog.com"
|
|
const POSTHOG_LEGACY_EVENT = process.env.POSTHOG_LEGACY_EVENT || process.env.POSTHOG_EVENT || "download"
|
|
const POSTHOG_V2_EVENT = process.env.POSTHOG_V2_EVENT || "release_asset_snapshot"
|
|
const POSTHOG_DISTINCT_ID = process.env.POSTHOG_DISTINCT_ID || "openwork-download"
|
|
const GITHUB_REPO = process.env.GITHUB_REPO || "different-ai/openwork"
|
|
const STATS_FILE = process.env.STATS_FILE || "STATS.md"
|
|
const STATS_V2_FILE = process.env.STATS_V2_FILE || "STATS_V2.md"
|
|
|
|
const LEGACY_HEADER = [
|
|
"# Download Stats",
|
|
"",
|
|
"Legacy cumulative release-asset totals. For classified v2 buckets, see `STATS_V2.md`.",
|
|
"",
|
|
"| Date | GitHub Downloads | Total |",
|
|
"|------|------------------|-------|",
|
|
].join("\n")
|
|
|
|
const V2_HEADER = [
|
|
"# Download Stats V2",
|
|
"",
|
|
"Classified GitHub release asset snapshots. `Manual installs` counts installer downloads (`.dmg`, `.msi`, `.deb`, `.rpm`). `Updater` counts updater artifacts (`latest.json`, macOS updater bundles, updater signatures). `Other` captures signatures, sidecars, and uncategorized assets.",
|
|
"",
|
|
"| Date | Manual Installs | Updater | Other | All Release Assets |",
|
|
"|------|-----------------|---------|-------|--------------------|",
|
|
].join("\n")
|
|
|
|
const MANUAL_INSTALL_SUFFIXES = [".dmg", ".msi", ".deb", ".rpm", ".pkg", ".appimage", ".exe"]
|
|
const UPDATER_SUFFIXES = ["latest.json", ".blockmap", ".app.tar.gz", ".app.tar.gz.sig"]
|
|
const V2_BUCKETS = ["manual_install", "updater", "other", "all"]
|
|
|
|
async function sendToPostHog(event, properties, distinctId = POSTHOG_DISTINCT_ID) {
|
|
if (!POSTHOG_KEY) {
|
|
console.warn("POSTHOG_KEY not set, skipping PostHog event")
|
|
return
|
|
}
|
|
|
|
const response = await fetch(`${POSTHOG_HOST}/i/v0/e/`, {
|
|
method: "POST",
|
|
headers: {
|
|
"Content-Type": "application/json",
|
|
},
|
|
body: JSON.stringify({
|
|
distinct_id: distinctId,
|
|
api_key: POSTHOG_KEY,
|
|
event,
|
|
properties,
|
|
}),
|
|
}).catch(() => null)
|
|
|
|
if (response && !response.ok) {
|
|
console.warn(`PostHog API error: ${response.status}`)
|
|
}
|
|
}
|
|
|
|
function isDesktopRelease(release) {
|
|
return typeof release?.tag_name === "string" && /^v\d/.test(release.tag_name)
|
|
}
|
|
|
|
export function classifyAsset(release, asset) {
|
|
const name = String(asset?.name || "").toLowerCase()
|
|
|
|
if (!name) return "other"
|
|
|
|
if (isDesktopRelease(release)) {
|
|
if (UPDATER_SUFFIXES.some((suffix) => name === suffix || name.endsWith(suffix))) {
|
|
return "updater"
|
|
}
|
|
|
|
if (MANUAL_INSTALL_SUFFIXES.some((suffix) => name.endsWith(suffix))) {
|
|
return "manual_install"
|
|
}
|
|
}
|
|
|
|
return "other"
|
|
}
|
|
|
|
async function fetchReleases() {
|
|
const releases = []
|
|
let page = 1
|
|
const perPage = 100
|
|
const headers = {
|
|
Accept: "application/vnd.github+json",
|
|
"User-Agent": "openwork-download-stats",
|
|
}
|
|
const token = process.env.GITHUB_TOKEN
|
|
|
|
if (token) {
|
|
headers.Authorization = `Bearer ${token}`
|
|
}
|
|
|
|
while (true) {
|
|
const url = `https://api.github.com/repos/${GITHUB_REPO}/releases?page=${page}&per_page=${perPage}`
|
|
const response = await fetch(url, { headers })
|
|
|
|
if (!response.ok) {
|
|
throw new Error(`GitHub API error: ${response.status} ${response.statusText}`)
|
|
}
|
|
|
|
const batch = await response.json()
|
|
if (!Array.isArray(batch) || batch.length === 0) break
|
|
|
|
releases.push(...batch)
|
|
console.log(`Fetched page ${page} with ${batch.length} releases`)
|
|
|
|
if (batch.length < perPage) break
|
|
page += 1
|
|
await new Promise((resolve) => setTimeout(resolve, 1000))
|
|
}
|
|
|
|
return releases
|
|
}
|
|
|
|
export function calculate(releases) {
|
|
let legacyTotal = 0
|
|
const buckets = {
|
|
manual_install: 0,
|
|
updater: 0,
|
|
other: 0,
|
|
}
|
|
const stats = []
|
|
|
|
for (const release of releases) {
|
|
let downloads = 0
|
|
const assets = []
|
|
|
|
for (const asset of release.assets ?? []) {
|
|
const count = Number(asset.download_count) || 0
|
|
const bucket = classifyAsset(release, asset)
|
|
|
|
downloads += count
|
|
legacyTotal += count
|
|
buckets[bucket] += count
|
|
assets.push({
|
|
name: asset.name,
|
|
downloads: count,
|
|
bucket,
|
|
})
|
|
}
|
|
|
|
stats.push({
|
|
tag: release.tag_name,
|
|
name: release.name,
|
|
downloads,
|
|
assets,
|
|
})
|
|
}
|
|
|
|
return {
|
|
total: legacyTotal,
|
|
legacyTotal,
|
|
buckets: {
|
|
...buckets,
|
|
all: legacyTotal,
|
|
},
|
|
stats,
|
|
}
|
|
}
|
|
|
|
export function parseCountCell(cell) {
|
|
const match = String(cell || "").match(/-?[\d,]+/)
|
|
if (!match) return 0
|
|
return parseInt(match[0].replace(/,/g, ""), 10)
|
|
}
|
|
|
|
export function parseLastDataRow(content, expectedColumns) {
|
|
const lines = String(content || "")
|
|
.trim()
|
|
.split("\n")
|
|
|
|
for (let i = lines.length - 1; i >= 0; i -= 1) {
|
|
const line = lines[i].trim()
|
|
if (!line.startsWith("|")) continue
|
|
|
|
const cells = line
|
|
.split("|")
|
|
.map((cell) => cell.trim())
|
|
.filter(Boolean)
|
|
|
|
if (cells.length !== expectedColumns) continue
|
|
if (cells[0] === "Date") continue
|
|
if (cells.every((cell) => /^-+$/.test(cell))) continue
|
|
|
|
return cells
|
|
}
|
|
|
|
return null
|
|
}
|
|
|
|
function formatChange(change) {
|
|
if (change > 0) return ` (+${change.toLocaleString()})`
|
|
if (change < 0) return ` (${change.toLocaleString()})`
|
|
return " (+0)"
|
|
}
|
|
|
|
function withTrailingNewline(content) {
|
|
return content.endsWith("\n") ? content : `${content}\n`
|
|
}
|
|
|
|
async function loadOrInitialize(filePath, header) {
|
|
try {
|
|
return await fs.readFile(filePath, "utf8")
|
|
} catch {
|
|
return `${header}\n`
|
|
}
|
|
}
|
|
|
|
async function saveLegacyStats(githubTotal) {
|
|
const date = new Date().toISOString().split("T")[0]
|
|
let content = await loadOrInitialize(STATS_FILE, LEGACY_HEADER)
|
|
|
|
if (!content.includes("| Date | GitHub Downloads | Total |")) {
|
|
content = `${LEGACY_HEADER}\n`
|
|
}
|
|
|
|
const previous = parseLastDataRow(content, 3)
|
|
const previousGithub = previous ? parseCountCell(previous[1]) : 0
|
|
const previousTotal = previous ? parseCountCell(previous[2]) : 0
|
|
|
|
const githubChange = githubTotal - previousGithub
|
|
const totalChange = githubTotal - previousTotal
|
|
const line = `| ${date} | ${githubTotal.toLocaleString()}${formatChange(githubChange)} | ${githubTotal.toLocaleString()}${formatChange(totalChange)} |\n`
|
|
|
|
await fs.writeFile(STATS_FILE, `${withTrailingNewline(content)}${line}`, "utf8")
|
|
|
|
console.log(
|
|
`\nAppended legacy stats to ${STATS_FILE}: GitHub ${githubTotal.toLocaleString()}${formatChange(githubChange)}, Total ${githubTotal.toLocaleString()}${formatChange(totalChange)}`,
|
|
)
|
|
|
|
return {
|
|
date,
|
|
totals: {
|
|
github: githubTotal,
|
|
total: githubTotal,
|
|
},
|
|
deltas: {
|
|
github: githubChange,
|
|
total: totalChange,
|
|
},
|
|
}
|
|
}
|
|
|
|
async function saveV2Stats(totals) {
|
|
const date = new Date().toISOString().split("T")[0]
|
|
let content = await loadOrInitialize(STATS_V2_FILE, V2_HEADER)
|
|
|
|
if (!content.includes("| Date | Manual Installs | Updater | Other | All Release Assets |")) {
|
|
content = `${V2_HEADER}\n`
|
|
}
|
|
|
|
const previous = parseLastDataRow(content, 5)
|
|
const previousTotals = {
|
|
manual_install: previous ? parseCountCell(previous[1]) : 0,
|
|
updater: previous ? parseCountCell(previous[2]) : 0,
|
|
other: previous ? parseCountCell(previous[3]) : 0,
|
|
all: previous ? parseCountCell(previous[4]) : 0,
|
|
}
|
|
|
|
const deltas = {
|
|
manual_install: totals.manual_install - previousTotals.manual_install,
|
|
updater: totals.updater - previousTotals.updater,
|
|
other: totals.other - previousTotals.other,
|
|
all: totals.all - previousTotals.all,
|
|
}
|
|
|
|
const line = `| ${date} | ${totals.manual_install.toLocaleString()}${formatChange(deltas.manual_install)} | ${totals.updater.toLocaleString()}${formatChange(deltas.updater)} | ${totals.other.toLocaleString()}${formatChange(deltas.other)} | ${totals.all.toLocaleString()}${formatChange(deltas.all)} |`
|
|
|
|
await fs.writeFile(STATS_V2_FILE, `${withTrailingNewline(content)}${line}\n`, "utf8")
|
|
|
|
console.log(
|
|
`Appended classified stats to ${STATS_V2_FILE}: manual ${totals.manual_install.toLocaleString()}${formatChange(deltas.manual_install)}, updater ${totals.updater.toLocaleString()}${formatChange(deltas.updater)}, other ${totals.other.toLocaleString()}${formatChange(deltas.other)}, all ${totals.all.toLocaleString()}${formatChange(deltas.all)}`,
|
|
)
|
|
|
|
return {
|
|
date,
|
|
totals,
|
|
deltas,
|
|
}
|
|
}
|
|
|
|
async function sendClassifiedSnapshot(snapshot) {
|
|
for (const bucket of V2_BUCKETS) {
|
|
await sendToPostHog(
|
|
POSTHOG_V2_EVENT,
|
|
{
|
|
metric_version: 2,
|
|
bucket,
|
|
total: snapshot.totals[bucket],
|
|
delta: snapshot.deltas[bucket],
|
|
source: "github",
|
|
repo: GITHUB_REPO,
|
|
date: snapshot.date,
|
|
},
|
|
`${POSTHOG_DISTINCT_ID}-${bucket}`,
|
|
)
|
|
}
|
|
}
|
|
|
|
export async function main() {
|
|
console.log(`Fetching GitHub releases for ${GITHUB_REPO}...\n`)
|
|
|
|
const releases = await fetchReleases()
|
|
console.log(`\nFetched ${releases.length} releases total\n`)
|
|
|
|
const { total: githubTotal, buckets } = calculate(releases)
|
|
const legacySnapshot = await saveLegacyStats(githubTotal)
|
|
const v2Snapshot = await saveV2Stats(buckets)
|
|
|
|
await sendToPostHog(POSTHOG_LEGACY_EVENT, {
|
|
count: githubTotal,
|
|
source: "github",
|
|
repo: GITHUB_REPO,
|
|
date: legacySnapshot.date,
|
|
})
|
|
|
|
await sendClassifiedSnapshot(v2Snapshot)
|
|
|
|
console.log("=".repeat(60))
|
|
console.log(`TOTAL DOWNLOADS: ${githubTotal.toLocaleString()}`)
|
|
console.log(` Legacy all assets: ${githubTotal.toLocaleString()}`)
|
|
console.log(` Manual installs: ${buckets.manual_install.toLocaleString()}`)
|
|
console.log(` Updater: ${buckets.updater.toLocaleString()}`)
|
|
console.log(` Other: ${buckets.other.toLocaleString()}`)
|
|
console.log("=".repeat(60))
|
|
}
|
|
|
|
if (process.argv[1] && import.meta.url === pathToFileURL(resolve(process.argv[1])).href) {
|
|
await main()
|
|
}
|