diff --git a/.gitea/workflows/release-please.yml b/.gitea/workflows/release-please.yml index e074a65..7056282 100644 --- a/.gitea/workflows/release-please.yml +++ b/.gitea/workflows/release-please.yml @@ -49,6 +49,21 @@ jobs: echo "created label: ${name}" done + # The label fix above is not retroactive. PR #22 was merged with + # `autorelease: pending` but its head branch had already been deleted, + # so the action reports `Bad branch name: refs/pull/22/head`, creates no + # tag and leaves the label behind. Every later run then aborts with + # "There are untagged, merged release PRs outstanding" and never opens a + # new release PR - green, no tags. This step reconciles that state before + # the action runs: mark a pending PR tagged when its tag already exists, + # or recreate the tag when the head branch is gone and release-please + # therefore cannot. See scripts/reconcile-release-please.mjs and + # OKF_Nuxt/decisions/release-engineering.md. + - name: Reconcile stale release-please state + env: + GITEA_TOKEN: ${{ secrets.PR_GITEA_TOKEN }} + run: node scripts/reconcile-release-please.mjs + - uses: joaquinjsb/gitea-release-please-action@v4 with: # One well-scoped token for all workflow API work (see diff --git a/OKF_Nuxt/decisions/release-engineering.md b/OKF_Nuxt/decisions/release-engineering.md index 4e0e48d..98ae6ea 100644 --- a/OKF_Nuxt/decisions/release-engineering.md +++ b/OKF_Nuxt/decisions/release-engineering.md @@ -16,6 +16,9 @@ sources: - id: workflow resource: .gitea/workflows/release-please.yml title: release-please workflow + - id: reconcile + resource: scripts/reconcile-release-please.mjs + title: release-please state reconciliation --- # Decision @@ -97,6 +100,49 @@ confirmed by comparison, not inference: while `fix/release_please` still existed, PR #23 reported `head.ref = fix/release_please`; every PR whose branch was gone reported `refs/pull//head`. +# A pending label outlives the branch and blocks every later release (2026-10-31) + +Flipping `default_delete_branch_after_merge` to `false` only protects +branches deleted *after* the change. PR #22's branch was already gone, so +its `head.ref` stayed `refs/pull/22/head` and its `autorelease: pending` +label stayed attached. Run 143 (task 475, 2026-10-27, the run immediately +after #22 merged) shows the full deadlock: + +``` +❯ Found pull request #22: 'chore: release main' +✖ Bad branch name: refs/pull/22/head +... +✔ Building candidate release pull request for path: . +❯ Found pull request #22: 'chore: release main' +⚠ There are untagged, merged release PRs outstanding - aborting +::set-output:: prs_created=false +::set-output:: releases_created=false +``` + +The first block fails the tagging phase. The second finds the same +still-pending PR and aborts the propose phase, so no new release PR is +even opened. Every later run (145, 148, 151, 153, 162, 164, 167) has the +same shape. The hand-created `v1.4.0` tag restores the baseline (`found: +v1.4.0`) but does not clear the label, so it does not break the +deadlock. This is the current reason the pipeline is still healthy-looking +and tagless. + +The workflow now reconciles that state before the action runs +(`scripts/reconcile-release-please.mjs`): + +* merged + `autorelease: pending` + a tag already at the merge commit -> + replace the label with `autorelease: tagged`; +* merged + `autorelease: pending` + head branch gone + no tag -> create + the tag from the version recorded in the manifest at the merge commit + (the exact tag release-please would have made), then swap the label; +* merged + `autorelease: pending` + head branch still present -> leave + it; release-please tags it in the same run. + +The step is idempotent and runs on every push to `main` and every manual +dispatch, so a deleted branch cannot silently poison the release pipeline +again. #20 and #21 are not labelled pending, so they do not block; their +tags remain the one-time manual recovery in the table below. + # Recovering the versions that never got a tag The label alone cannot recover them — #20, #21 and #22 all lost their head @@ -123,6 +169,11 @@ whole history. * That the release phase tags correctly once the head branch survives a merge. The next release cycle proves it. +* That the reconcile step's tag-creation fallback works with a live + token. Only the tag-already-exists path was exercised, in dry-run, + against the live PR #22. The fallback is written from the same Gitea + API shapes (`POST /tags`, `PUT /issues/{index}/labels`) the rest of the + workflow uses. * That `RELEASE_PLEASE_TOKEN_CV_SITE_NUXT` carries the `write:issue` scope the same way `PR_GITEA_TOKEN` needed it; the previous failure was an immediate API rejection consistent with a scope problem. diff --git a/OKF_Nuxt/log.md b/OKF_Nuxt/log.md index 2fa9649..f3b3b22 100644 --- a/OKF_Nuxt/log.md +++ b/OKF_Nuxt/log.md @@ -1,5 +1,9 @@ # Update Log +## 2026-10-31 (release-please still never tagged: the stale pending label) + +* **Fix**: [release-please.yml](../.gitea/workflows/release-please.yml) now runs [scripts/reconcile-release-please.mjs](../scripts/reconcile-release-please.mjs) before the action. The branch-deletion fix from 2026-10-27 only protects branches deleted after the setting changed; PR #22's branch was already gone, so its `autorelease: pending` label was never cleared. The action therefore finds #22 on every run, logs `Bad branch name: refs/pull/22/head`, creates no tag, and then aborts the propose phase with `There are untagged, merged release PRs outstanding` - `prs_created=false`, `releases_created=false`, exit code 0. Evidence: run 143 (task 475, immediately after #22 merged) and every run through 167 has that exact shape; the hand-created `v1.4.0` tag makes the baseline work (`found: v1.4.0`) but does not clear the label. The reconcile script marks a pending PR tagged when its tag already exists, and recreates the tag from the manifest at the merge commit when the head branch is gone and the tag is missing. A dry run against the live API correctly matches #22 to `v1.4.0` and proposes `autorelease: tagged`. See [Release engineering](decisions/release-engineering.md). + ## 2026-10-30 (PR-Agent moved into the Gitea compose stack) * **Refactor**: the `pr-agent` service now lives in `/home/noel/self-hosted/gitea/docker-compose.yml` with `/home/noel/self-hosted/gitea/pr-agent.env`. The separate `/home/noel/self-hosted/pr-agent` stack and the unused `/opt` operator-access scripts were removed; the service is managed with the Gitea stack. diff --git a/scripts/reconcile-release-please.mjs b/scripts/reconcile-release-please.mjs new file mode 100644 index 0000000..116522b --- /dev/null +++ b/scripts/reconcile-release-please.mjs @@ -0,0 +1,176 @@ +// 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) +})