PR Check / Security scan (Snyk) (pull_request) Skipped
PR Check / Lint + typecheck (pull_request) Successful in 1m8s
PR Check / Secret scan (gitleaks) (pull_request) Successful in 6s
PR Check / Dependency audit (pull_request) Failing after 9s
PR Check / Dockerfile lint (droast) (pull_request) Successful in 4s
PR #22 kept autorelease: pending after its head branch was deleted. Gitea rewrites head.ref to refs/pull/22/head, so the action cannot tag it and every later run then aborts with 'There are untagged, merged release PRs outstanding' - no new release PR is ever opened. Add a reconciliation step that marks a pending PR tagged when its tag already exists, and recreates the tag from the manifest at the merge commit when the branch is gone and the tag is missing.
177 lines
6.5 KiB
JavaScript
177 lines
6.5 KiB
JavaScript
// Repairs the release-please state that its Gitea fork cannot recover from.
|
|
//
|
|
// Why this exists (evidence in OKF_Nuxt/decisions/release-engineering.md):
|
|
//
|
|
// Gitea rewrites a merged PR's `head.ref` to `refs/pull/<n>/head` when the
|
|
// head branch is deleted. The fork parses that field as the release branch,
|
|
// logs `Bad branch name`, creates no tag - and still exits successfully.
|
|
// The merged PR keeps `autorelease: pending`, so every later run aborts with
|
|
// `There are untagged, merged release PRs outstanding` and opens no new
|
|
// release PR. That is a permanent deadlock, not a transient failure.
|
|
//
|
|
// This script runs before the action and reconciles the state:
|
|
//
|
|
// * a merged pending PR whose merge commit already has a tag -> swap
|
|
// `autorelease: pending` for `autorelease: tagged` (the release exists,
|
|
// only the label is stale);
|
|
// * a merged pending PR whose head branch is gone and has no tag -> create
|
|
// the tag from the version recorded in the manifest at that merge commit.
|
|
// This is exactly the tag release-please would have made if the branch had
|
|
// survived; without it the PR blocks every future release;
|
|
// * a merged pending PR whose head branch still exists -> leave it alone,
|
|
// release-please tags it in the same run.
|
|
//
|
|
// Run locally against the public API with:
|
|
// DRY_RUN=1 node scripts/reconcile-release-please.mjs
|
|
// Reads work unauthenticated for a public repository; writes are skipped.
|
|
|
|
const API_URL = process.env.GITHUB_API_URL
|
|
const REPOSITORY = process.env.GITHUB_REPOSITORY
|
|
const TOKEN = process.env.GITEA_TOKEN
|
|
const DRY_RUN = process.env.DRY_RUN === '1' || process.argv.includes('--dry-run')
|
|
|
|
const PENDING = 'autorelease: pending'
|
|
const TAGGED = 'autorelease: tagged'
|
|
|
|
if (!API_URL || !REPOSITORY) {
|
|
console.error('::error::GITHUB_API_URL and GITHUB_REPOSITORY must be set')
|
|
process.exit(1)
|
|
}
|
|
if (!TOKEN && !DRY_RUN) {
|
|
console.error('::error::GITEA_TOKEN is required (or set DRY_RUN=1)')
|
|
process.exit(1)
|
|
}
|
|
|
|
const repoUrl = `${API_URL}/repos/${REPOSITORY}`
|
|
|
|
const api = async (path, init = {}) => {
|
|
const response = await fetch(`${repoUrl}${path}`, {
|
|
...init,
|
|
headers: {
|
|
Accept: 'application/json',
|
|
...(TOKEN ? { Authorization: `token ${TOKEN}` } : {}),
|
|
...(init.headers ?? {}),
|
|
},
|
|
})
|
|
const body = await response.text()
|
|
if (!response.ok) {
|
|
throw new Error(`${init.method ?? 'GET'} ${path} -> HTTP ${response.status}: ${body.slice(0, 300)}`)
|
|
}
|
|
return body ? JSON.parse(body) : null
|
|
}
|
|
|
|
// Gitea caps page size at 50. Follow pages until a short page ends the list.
|
|
const listAll = async (path) => {
|
|
const items = []
|
|
for (let page = 1; ; page++) {
|
|
const separator = path.includes('?') ? '&' : '?'
|
|
const batch = await api(`${path}${separator}limit=50&page=${page}`)
|
|
items.push(...batch)
|
|
if (batch.length < 50) return items
|
|
}
|
|
}
|
|
|
|
const replaceLabels = async (number, labels) => {
|
|
if (DRY_RUN) {
|
|
console.log(`[dry-run] #${number}: labels -> ${labels.join(', ')}`)
|
|
return
|
|
}
|
|
await api(`/issues/${number}/labels`, {
|
|
method: 'PUT',
|
|
headers: { 'Content-Type': 'application/json' },
|
|
body: JSON.stringify({ labels }),
|
|
})
|
|
}
|
|
|
|
const createTag = async (name, sha) => {
|
|
if (DRY_RUN) {
|
|
console.log(`[dry-run] create tag ${name} at ${sha}`)
|
|
return
|
|
}
|
|
await api('/tags', {
|
|
method: 'POST',
|
|
headers: { 'Content-Type': 'application/json' },
|
|
body: JSON.stringify({ tag_name: name, target: sha, message: `Release ${name}` }),
|
|
})
|
|
}
|
|
|
|
const versionAt = async (sha) => {
|
|
const file = await api(`/contents/.release-please-manifest.json?ref=${sha}`)
|
|
if (!file?.content) throw new Error(`no manifest content at ${sha}`)
|
|
const manifest = JSON.parse(Buffer.from(file.content, 'base64').toString('utf8'))
|
|
// Single-package repository: the root path is ".". Keep a fallback so a
|
|
// future second package cannot silently produce `vundefined`.
|
|
return manifest['.'] ?? Object.values(manifest)[0]
|
|
}
|
|
|
|
const run = async () => {
|
|
const tags = await listAll('/tags')
|
|
const tagSha = new Map(tags.map(tag => [tag.commit?.sha, tag.name]))
|
|
const tagsByName = new Map(tags.map(tag => [tag.name, tag.commit?.sha]))
|
|
|
|
const pulls = await listAll('/pulls?state=closed')
|
|
const pending = pulls
|
|
.filter(pull => pull.merged_at)
|
|
.filter(pull => (pull.labels ?? []).some(label => label.name === PENDING))
|
|
.sort((a, b) => a.number - b.number)
|
|
|
|
if (pending.length === 0) {
|
|
console.log('No merged release PR is pending - nothing to reconcile.')
|
|
return
|
|
}
|
|
|
|
const failures = []
|
|
|
|
for (const pull of pending) {
|
|
const mergeSha = pull.merge_commit_sha
|
|
const headRef = pull.head?.ref ?? ''
|
|
const branchGone = headRef.startsWith('refs/pull/') || headRef === ''
|
|
const existingTag = tagSha.get(mergeSha)
|
|
const labels = (pull.labels ?? []).map(label => label.name)
|
|
|
|
if (existingTag) {
|
|
console.log(`#${pull.number}: ${existingTag} already points at merge commit ${mergeSha} - marking as tagged`)
|
|
const next = labels.filter(name => name !== PENDING)
|
|
if (!next.includes(TAGGED)) next.push(TAGGED)
|
|
await replaceLabels(pull.number, next)
|
|
continue
|
|
}
|
|
|
|
if (!branchGone) {
|
|
console.log(`#${pull.number}: head branch ${headRef} still exists - leaving it for release-please to tag`)
|
|
continue
|
|
}
|
|
|
|
// The branch is gone and no tag exists, so release-please will never get
|
|
// past `Bad branch name` for this PR. Recreate the tag it should have
|
|
// made, using the version the merged release PR wrote into the manifest.
|
|
try {
|
|
const version = await versionAt(mergeSha)
|
|
if (!version) throw new Error('manifest has no version for the root package')
|
|
const name = `v${version}`
|
|
if (tagsByName.has(name)) {
|
|
throw new Error(`${name} already exists at ${tagsByName.get(name)}, not at merge commit ${mergeSha}; refusing to move a release tag`)
|
|
}
|
|
console.log(`#${pull.number}: head branch is gone (${headRef}) - creating ${name} at ${mergeSha}`)
|
|
await createTag(name, mergeSha)
|
|
const next = labels.filter(label => label !== PENDING)
|
|
if (!next.includes(TAGGED)) next.push(TAGGED)
|
|
await replaceLabels(pull.number, next)
|
|
}
|
|
catch (error) {
|
|
failures.push(`#${pull.number}: ${error.message}`)
|
|
}
|
|
}
|
|
|
|
if (failures.length > 0) {
|
|
for (const failure of failures) console.error(`::error::${failure}`)
|
|
console.error('::error::release-please state is unrecoverable automatically; repair the PR/tag by hand before the next release')
|
|
process.exit(1)
|
|
}
|
|
}
|
|
|
|
run().catch((error) => {
|
|
console.error(`::error::${error.message}`)
|
|
process.exit(1)
|
|
})
|