Files
crank/scripts/publish-gitea-release.py
bsodfather 54ce770682
CI / Rust Checks (pull_request) Failing after 13m41s
CI / UI Checks (pull_request) Skipped
CI / Frontend E2E (pull_request) Skipped
CI / Community Image Smoke (pull_request) Skipped
CI / Deploy (pull_request) Skipped
Community Release / release (push) Failing after 13m33s
feat(epic3): deliver the accepted Epic 3 scope through Story 3.17
Recovery delivery of the accumulated, TL-accepted Epic 3 work that had never been
committed to Git (stories 3.6-3.17, see the crank board). Story 3.18 is not accepted
yet and is deliberately excluded: its logging surface, its capability registration,
its oracle projections and its tests are not part of this tree.

Accepted scope
- 3.6 typed static Resource Drafts; 3.7 publication and exact binding of static
  Resource Versions; 3.8 MCP discovery/read and revocation of static Resources;
- 3.9 Resource import/export in API and UI plus TLS dependency maintenance;
  3.10 REST-backed Resource templates; 3.11 shared REST read runtime and the MCP
  revision/capability foundation;
- 3.12 parameterised Prompt Drafts with preview; 3.13 Prompt publication and exact
  version binding to Agents; 3.14 MCP prompts; 3.15 Prompt import/export;
- 3.16 composite Prompts with published Resources (dependency content scan plus
  dynamic read through the accepted 3.11 runtime, admin preview and MCP prompts/get);
- 3.17 bounded MCP completion suggestions from typed published schemas and the
  resources/list admission fix for bound template publications.

Accepted evidence being reused (unchanged code paths)
- 3.16 candidate: core 7, admin-api 22, registry 4, mcp-server 4, UI 6; one final
  `just verify` run 1651 passed / 0 failed / 2 ignored.
- 3.17 candidate: full run 1672 passed / 0 failed / 2 ignored, QA targeted reruns and
  a real MCP Inspector 2.12.0 client smoke.

Delivery engineering in this commit
- CI: one event per change (feature branches are gated by their pull request, push
  runs only on main), story events run the changed packages, the full workspace suite
  stays the feature/release gate; no cache/sharding without a measured runner check.
- Release: the packaged archives, checksums and SBOM are now uploaded to the Gitea
  release entry of the tag instead of dying with the runner workspace.

Not included on purpose: Story 3.18 work, build caches, runtime databases, local
credentials and scratch evidence.

Refs: crank kanban t_e39d7263; baseline 1b6db09bd1.
2026-10-25 09:08:22 +00:00

105 lines
4.1 KiB
Python

#!/usr/bin/env python3
"""Attach the packaged release artifacts to the Gitea release of one tag.
The release workflow builds the archives, the checksums file and the SBOM into `dist/`; this script
is what makes them durable: it upserts the release entry of the tag and uploads every artifact to it,
so a published version keeps its artifacts and checksums after the runner workspace is gone.
The token is read from `GITEA_TOKEN` only; it is never printed, logged or written to disk.
"""
from __future__ import annotations
import argparse
import json
import mimetypes
import os
import sys
import urllib.error
import urllib.request
from pathlib import Path
TIMEOUT_SECONDS = 120
def _json(url: str, token: str, method: str = "GET", payload: dict | None = None) -> dict:
headers = {"Authorization": f"token {token}", "Accept": "application/json"}
data = None
if payload is not None:
data = json.dumps(payload).encode("utf-8")
headers["Content-Type"] = "application/json"
request = urllib.request.Request(url, data=data, headers=headers, method=method)
with urllib.request.urlopen(request, timeout=TIMEOUT_SECONDS) as response:
return json.loads(response.read() or b"{}")
def _upload(url: str, token: str, path: Path) -> dict:
headers = {
"Authorization": f"token {token}",
"Content-Type": mimetypes.guess_type(path.name)[0] or "application/octet-stream",
}
request = urllib.request.Request(url, data=path.read_bytes(), headers=headers, method="POST")
with urllib.request.urlopen(request, timeout=TIMEOUT_SECONDS) as response:
return json.loads(response.read() or b"{}")
def release_artifacts(dist: Path) -> list[Path]:
"""Every regular file directly in `dist/`, in a stable order; nested build dirs are ignored."""
return sorted(path for path in dist.iterdir() if path.is_file() and not path.name.startswith("."))
def publish(api: str, repo: str, tag: str, title: str, notes: Path, dist: Path, prerelease: bool, token: str) -> int:
base = f"{api.rstrip('/')}/repos/{repo}"
# The notes file is the release body, not an artifact of the release.
artifacts = [path for path in release_artifacts(dist) if path.name != notes.name]
if not artifacts:
print(f"no release artifacts in {dist}", file=sys.stderr)
return 2
try:
release = _json(f"{base}/releases/tags/{tag}", token)
except urllib.error.HTTPError as error:
if error.code != 404:
raise
release = _json(
f"{base}/releases",
token,
"POST",
{
"tag_name": tag,
"name": title,
"body": notes.read_text(encoding="utf-8"),
"draft": False,
"prerelease": prerelease,
},
)
existing = {asset["name"] for asset in release.get("assets") or []}
for path in artifacts:
if path.name in existing:
print(f"skip existing asset {path.name}")
continue
uploaded = _upload(f"{base}/releases/{release['id']}/assets?name={path.name}", token, path)
print(f"uploaded {path.name} -> {uploaded.get('browser_download_url', 'ok')}")
print(f"release {tag} id={release['id']} artifacts={len(artifacts)}")
return 0
def main() -> int:
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument("--api", required=True, help="API root, e.g. https://git.itexp.me/api/v1")
parser.add_argument("--repo", required=True, help="owner/name")
parser.add_argument("--tag", required=True)
parser.add_argument("--title", required=True)
parser.add_argument("--notes-file", type=Path, required=True)
parser.add_argument("--dist", type=Path, required=True)
parser.add_argument("--prerelease", action="store_true")
args = parser.parse_args()
token = os.environ.get("GITEA_TOKEN", "")
if not token:
print("GITEA_TOKEN is required to publish release artifacts", file=sys.stderr)
return 2
return publish(args.api, args.repo, args.tag, args.title, args.notes_file, args.dist, args.prerelease, token)
if __name__ == "__main__":
raise SystemExit(main())