// 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//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) })