Agent Zero AI framework
Merge pull request #1324 from nicolasleao/main
frdel5ba7cfc99fe6
diff --git a/.github/scripts/docker_release_plan.py b/.github/scripts/docker_release_plan.pynew file mode 100644index 000000000..8e7503958--- /dev/null+++ b/.github/scripts/docker_release_plan.py@@ -0,0 +1,580 @@+#!/usr/bin/env python3+from __future__ import annotations++import json+import os+import re+import subprocess+import sys+from dataclasses import asdict, dataclass+++def fail(message: str) -> None:+ print(message, file=sys.stderr)+ raise SystemExit(1)+++def write_output(name: str, value: str) -> None:+ output_path = os.environ.get("GITHUB_OUTPUT")+ if not output_path:+ return+ with open(output_path, "a", encoding="utf-8") as handle:+ handle.write(f"{name}<<__EOF__\n{value}\n__EOF__\n")+++def write_summary(lines: list[str]) -> None:+ summary_path = os.environ.get("GITHUB_STEP_SUMMARY")+ if not summary_path or not lines:+ return+ with open(summary_path, "a", encoding="utf-8") as handle:+ handle.write("## Docker publish plan\n\n")+ for line in lines:+ handle.write(f"- {line}\n")+++def run_command(*args: str, check: bool = True) -> subprocess.CompletedProcess[str]:+ result = subprocess.run(args, capture_output=True, text=True)+ if check and result.returncode != 0:+ command = " ".join(args)+ fail(f"Command failed ({command}):\n{result.stderr.strip()}")+ return result+++def git(*args: str, check: bool = True) -> str:+ return run_command("git", *args, check=check).stdout.strip()+++def docker_tag_exists(image_repo: str, tag: str) -> bool:+ result = run_command(+ "docker",+ "buildx",+ "imagetools",+ "inspect",+ f"{image_repo}:{tag}",+ check=False,+ )+ return result.returncode == 0+++def split_branches(raw: str) -> list[str]:+ parts = re.split(r"[\s,]+", raw.strip())+ return [part for part in parts if part]+++@dataclass(frozen=True)+class Config:+ allowed_branches: list[str]+ main_branch: str+ image_repo: str+ tag_pattern: re.Pattern[str]+ min_version: tuple[int, int]+ event_name: str+ source_ref_name: str+ source_ref_type: str+ manual_tag: str+ before_sha: str+ after_sha: str+++@dataclass(frozen=True)+class BranchState:+ branch: str+ valid_tags: list[str]+ latest_tag: str | None+++@dataclass+class Candidate:+ branch: str+ source_tag: str+ mode: str+ publish_version: bool+ publish_branch_tag: bool+ reason: str+++def load_config() -> Config:+ allowed_branches = split_branches(os.environ["ALLOWED_BRANCHES"])+ if not allowed_branches:+ fail("ALLOWED_BRANCHES must not be empty.")+ main_branch = os.environ["MAIN_BRANCH"].strip()+ if main_branch not in allowed_branches:+ fail("MAIN_BRANCH must also be listed in ALLOWED_BRANCHES.")++ tag_regex = os.environ["RELEASE_TAG_REGEX"]+ return Config(+ allowed_branches=allowed_branches,+ main_branch=main_branch,+ image_repo=os.environ["DOCKER_IMAGE_REPO"].strip(),+ tag_pattern=re.compile(tag_regex),+ min_version=(+ int(os.environ["MIN_RELEASE_MAJOR"]),+ int(os.environ["MIN_RELEASE_MINOR"]),+ ),+ event_name=os.environ["EVENT_NAME"].strip(),+ source_ref_name=os.environ.get("SOURCE_REF_NAME", "").strip(),+ source_ref_type=os.environ.get("SOURCE_REF_TYPE", "").strip(),+ manual_tag=os.environ.get("MANUAL_TAG", "").strip(),+ before_sha=os.environ.get("BEFORE_SHA", "").strip(),+ after_sha=os.environ.get("AFTER_SHA", "").strip(),+ )+++def parse_release_tag(config: Config, tag: str) -> tuple[int, int] | None:+ match = config.tag_pattern.fullmatch(tag)+ if not match:+ return None+ version = (int(match.group(1)), int(match.group(2)))+ if version < config.min_version:+ return None+ return version+++def tag_exists(tag: str) -> bool:+ return run_command("git", "rev-parse", "--verify", "--quiet", f"refs/tags/{tag}", check=False).returncode == 0+++def tag_commit(tag: str) -> str:+ return git("rev-list", "-n", "1", f"refs/tags/{tag}")+++def branch_contains_commit(branch: str, commit: str) -> bool:+ return (+ run_command(+ "git",+ "merge-base",+ "--is-ancestor",+ commit,+ f"origin/{branch}",+ check=False,+ ).returncode+ == 0+ )+++def ref_exists(ref: str) -> bool:+ if not ref or re.fullmatch(r"0{40}", ref):+ return False+ return run_command("git", "rev-parse", "--verify", "--quiet", f"{ref}^{{commit}}", check=False).returncode == 0+++def releasable_tags_for_ref(config: Config, ref: str) -> list[str]:+ if not ref_exists(ref):+ return []++ tagged_versions: list[tuple[tuple[int, int], str]] = []+ merged_tags = git("tag", "--merged", ref)+ for tag in merged_tags.splitlines():+ version = parse_release_tag(config, tag.strip())+ if version is None:+ continue+ tagged_versions.append((version, tag.strip()))++ tagged_versions.sort(key=lambda item: item[0])+ return [tag for _, tag in tagged_versions]+++def latest_releasable_tag_for_ref(config: Config, ref: str) -> str | None:+ valid_tags = releasable_tags_for_ref(config, ref)+ return valid_tags[-1] if valid_tags else None+++def collect_branch_states(config: Config, branches: list[str] | None = None) -> dict[str, BranchState]:+ states: dict[str, BranchState] = {}+ for branch in branches or config.allowed_branches:+ if run_command("git", "show-ref", "--verify", "--quiet", f"refs/remotes/origin/{branch}", check=False).returncode != 0:+ fail(f"Allowed branch origin/{branch} was not fetched.")++ valid_tags = releasable_tags_for_ref(config, f"origin/{branch}")+ states[branch] = BranchState(+ branch=branch,+ valid_tags=valid_tags,+ latest_tag=valid_tags[-1] if valid_tags else None,+ )+ return states+++def add_or_merge_candidate(candidates: dict[tuple[str, str, str], Candidate], candidate: Candidate) -> None:+ key = (candidate.branch, candidate.source_tag, candidate.mode)+ existing = candidates.get(key)+ if existing is None:+ candidates[key] = candidate+ return+ existing.publish_version = existing.publish_version or candidate.publish_version+ existing.publish_branch_tag = existing.publish_branch_tag or candidate.publish_branch_tag+ if candidate.reason not in existing.reason:+ existing.reason = f"{existing.reason}; {candidate.reason}"+++def plan_tag_push(config: Config, branch_states: dict[str, BranchState]) -> tuple[list[Candidate], list[str]]:+ source_tag = config.source_ref_name+ notes: list[str] = []+ version = parse_release_tag(config, source_tag)+ if version is None:+ return [], [f"Skipped `{source_tag}` because it does not match `v{{X}}.{{Y}}` or is below v{config.min_version[0]}.{config.min_version[1]}."]+ if not tag_exists(source_tag):+ return [], [f"Skipped `{source_tag}` because the tag is not present after checkout."]++ commit = tag_commit(source_tag)+ candidates: list[Candidate] = []+ found_branch = False+ for branch, state in branch_states.items():+ if not branch_contains_commit(branch, commit):+ continue+ found_branch = True+ if state.latest_tag != source_tag:+ notes.append(+ f"Skipped `{source_tag}` on `{branch}` because `{state.latest_tag}` is the highest release tag currently reachable from that branch."+ )+ continue+ candidates.append(+ Candidate(+ branch=branch,+ source_tag=source_tag,+ mode="push_latest_only",+ publish_version=branch == config.main_branch,+ publish_branch_tag=True,+ reason=f"Automatic build for the latest release tag on `{branch}`.",+ )+ )++ if not found_branch:+ notes.append(f"Skipped `{source_tag}` because it is not reachable from any allowed branch.")+ return candidates, notes+++def plan_branch_push(config: Config, branch_states: dict[str, BranchState]) -> tuple[list[Candidate], list[str]]:+ branch = config.source_ref_name+ if branch not in branch_states:+ return [], [f"Skipped `{branch}` because it is not an allowed release branch."]++ before_tag = latest_releasable_tag_for_ref(config, config.before_sha)+ after_tag = branch_states[branch].latest_tag+ if after_tag is None:+ return [], [f"Skipped `{branch}` because it has no releasable tags."]+ if before_tag == after_tag:+ return [], [f"Skipped `{branch}` because its highest release tag is still `{after_tag}`."]++ return [+ Candidate(+ branch=branch,+ source_tag=after_tag,+ mode="push_promoted_tag",+ publish_version=branch == config.main_branch,+ publish_branch_tag=True,+ reason=f"Automatic build for `{after_tag}` after it reached `{branch}`.",+ )+ ], []+++def plan_manual_exact(config: Config, branch_states: dict[str, BranchState]) -> tuple[list[Candidate], list[str]]:+ manual_tag = config.manual_tag+ if parse_release_tag(config, manual_tag) is None:+ fail(+ f"Manual tag `{manual_tag}` is invalid. Expected `v{{X}}.{{Y}}` with a minimum of v{config.min_version[0]}.{config.min_version[1]}."+ )+ if not tag_exists(manual_tag):+ fail(f"Manual tag `{manual_tag}` does not exist in the repository.")++ commit = tag_commit(manual_tag)+ notes: list[str] = []+ candidates: list[Candidate] = []+ for branch, state in branch_states.items():+ if not branch_contains_commit(branch, commit):+ continue+ if branch == config.main_branch:+ candidates.append(+ Candidate(+ branch=branch,+ source_tag=manual_tag,+ mode="manual_exact",+ publish_version=True,+ publish_branch_tag=state.latest_tag == manual_tag,+ reason=f"Manual rebuild for `{manual_tag}` on `{branch}`.",+ )+ )+ continue+ if state.latest_tag != manual_tag:+ notes.append(+ f"Skipped `{manual_tag}` on `{branch}` because non-main branches only publish their current branch tag and `{state.latest_tag}` is newer."+ )+ continue+ candidates.append(+ Candidate(+ branch=branch,+ source_tag=manual_tag,+ mode="manual_exact",+ publish_version=False,+ publish_branch_tag=True,+ reason=f"Manual rebuild for the current branch image on `{branch}`.",+ )+ )++ if not candidates:+ notes.append(f"No eligible images were found for manual tag `{manual_tag}`.")+ return candidates, notes+++def plan_manual_backfill(config: Config, branch_states: dict[str, BranchState]) -> tuple[list[Candidate], list[str]]:+ notes: list[str] = []+ candidates: dict[tuple[str, str, str], Candidate] = {}++ for branch, state in branch_states.items():+ if not state.valid_tags:+ notes.append(f"Branch `{branch}` has no releasable tags.")+ continue++ if branch == config.main_branch:+ for tag in state.valid_tags:+ if docker_tag_exists(config.image_repo, tag):+ continue+ add_or_merge_candidate(+ candidates,+ Candidate(+ branch=branch,+ source_tag=tag,+ mode="manual_backfill",+ publish_version=True,+ publish_branch_tag=False,+ reason=f"Missing Docker Hub tag `{tag}`.",+ ),+ )++ latest_tag = state.latest_tag+ if latest_tag and not docker_tag_exists(config.image_repo, "latest"):+ add_or_merge_candidate(+ candidates,+ Candidate(+ branch=branch,+ source_tag=latest_tag,+ mode="manual_backfill",+ publish_version=False,+ publish_branch_tag=True,+ reason="Missing Docker Hub tag `latest`.",+ ),+ )+ continue++ if not docker_tag_exists(config.image_repo, branch):+ add_or_merge_candidate(+ candidates,+ Candidate(+ branch=branch,+ source_tag=state.latest_tag,+ mode="manual_backfill",+ publish_version=False,+ publish_branch_tag=True,+ reason=f"Missing Docker Hub tag `{branch}`.",+ ),+ )++ if not candidates:+ notes.append("No missing Docker Hub tags were found.")+ return list(candidates.values()), notes+++def plan_command() -> None:+ config = load_config()+ branch_states = collect_branch_states(config)++ if config.event_name == "workflow_dispatch":+ if config.manual_tag:+ candidates, notes = plan_manual_exact(config, branch_states)+ else:+ candidates, notes = plan_manual_backfill(config, branch_states)+ elif config.event_name == "push":+ if config.source_ref_type == "tag":+ candidates, notes = plan_tag_push(config, branch_states)+ elif config.source_ref_type == "branch":+ candidates, notes = plan_branch_push(config, branch_states)+ else:+ fail(f"Unsupported push ref type: {config.source_ref_type}")+ else:+ fail(f"Unsupported event: {config.event_name}")++ summary_lines = [candidate.reason for candidate in candidates]+ summary_lines.extend(notes)++ matrix = {"include": [asdict(candidate) for candidate in candidates]}+ write_output("has_work", "true" if candidates else "false")+ write_output("matrix", json.dumps(matrix))+ write_summary(summary_lines)++ print(json.dumps(matrix, indent=2))+ for line in summary_lines:+ print(f"- {line}")+++def unique(items: list[str]) -> list[str]:+ seen: set[str] = set()+ output: list[str] = []+ for item in items:+ if item in seen:+ continue+ seen.add(item)+ output.append(item)+ return output+++def resolve_release_command() -> None:+ config = load_config()+ branch = os.environ["TARGET_BRANCH"].strip()+ source_tag = os.environ["TARGET_TAG"].strip()+ notes_dir = os.environ["RELEASE_NOTES_DIR"].strip()++ if branch != config.main_branch:+ write_output("should_release", "false")+ write_output("skip_reason", f"Branch `{branch}` does not publish GitHub releases.")+ return++ branch_state = collect_branch_states(config, [branch])[branch]+ if branch_state.latest_tag is None:+ write_output("should_release", "false")+ write_output("skip_reason", f"Branch `{branch}` has no releasable tags.")+ return++ if parse_release_tag(config, source_tag) is None or not tag_exists(source_tag):+ write_output("should_release", "false")+ write_output("skip_reason", f"Tag `{source_tag}` is not a releasable tag.")+ return++ commit = tag_commit(source_tag)+ if not branch_contains_commit(branch, commit):+ write_output("should_release", "false")+ write_output("skip_reason", f"Tag `{source_tag}` is no longer reachable from `{branch}`.")+ return++ if branch_state.latest_tag != source_tag:+ write_output("should_release", "false")+ write_output(+ "skip_reason",+ f"Tag `{source_tag}` is not the highest release tag on `{branch}`.",+ )+ return++ notes_path = os.path.join(notes_dir, f"{source_tag}.md")+ if not os.path.exists(notes_path):+ fail(+ f"Expected release notes file `{notes_path}` for GitHub release `{source_tag}`."+ )++ with open(notes_path, "r", encoding="utf-8") as handle:+ body = handle.read().strip()++ write_output("should_release", "true")+ write_output("release_tag", source_tag)+ write_output("release_name", source_tag)+ write_output("release_notes_path", notes_path)+ write_output("release_body", body or "No release notes.")+ print(source_tag)+++def resolve_build_command() -> None:+ config = load_config()+ branch = os.environ["TARGET_BRANCH"].strip()+ source_tag = os.environ["TARGET_TAG"].strip()+ mode = os.environ["TARGET_MODE"].strip()+ publish_version = os.environ["TARGET_PUBLISH_VERSION"].strip().lower() == "true"+ publish_branch_tag = os.environ["TARGET_PUBLISH_BRANCH_TAG"].strip().lower() == "true"++ branch_state = collect_branch_states(config, [branch])[branch]+ if branch_state.latest_tag is None:+ write_output("should_build", "false")+ write_output("skip_reason", f"Branch `{branch}` has no releasable tags.")+ return++ if parse_release_tag(config, source_tag) is None or not tag_exists(source_tag):+ write_output("should_build", "false")+ write_output("skip_reason", f"Tag `{source_tag}` is no longer available.")+ return++ commit = tag_commit(source_tag)+ if not branch_contains_commit(branch, commit):+ write_output("should_build", "false")+ write_output("skip_reason", f"Tag `{source_tag}` is no longer reachable from `{branch}`.")+ return++ mutable_tag = "latest" if branch == config.main_branch else branch+ tags_to_push: list[str] = []++ if mode == "push_latest_only":+ if branch_state.latest_tag != source_tag:+ write_output("should_build", "false")+ write_output(+ "skip_reason",+ f"Tag `{source_tag}` is no longer the highest release tag on `{branch}`.",+ )+ return+ if publish_version:+ tags_to_push.append(f"{config.image_repo}:{source_tag}")+ if publish_branch_tag:+ tags_to_push.append(f"{config.image_repo}:{mutable_tag}")++ elif mode == "push_promoted_tag":+ if branch_state.latest_tag != source_tag:+ write_output("should_build", "false")+ write_output(+ "skip_reason",+ f"Tag `{source_tag}` is no longer the highest release tag on `{branch}`.",+ )+ return+ if publish_version and not docker_tag_exists(config.image_repo, source_tag):+ tags_to_push.append(f"{config.image_repo}:{source_tag}")+ if publish_branch_tag:+ tags_to_push.append(f"{config.image_repo}:{mutable_tag}")++ elif mode == "manual_exact":+ if publish_version:+ tags_to_push.append(f"{config.image_repo}:{source_tag}")+ if publish_branch_tag and branch_state.latest_tag == source_tag:+ tags_to_push.append(f"{config.image_repo}:{mutable_tag}")++ elif mode == "manual_backfill":+ if publish_version and not docker_tag_exists(config.image_repo, source_tag):+ tags_to_push.append(f"{config.image_repo}:{source_tag}")+ if publish_branch_tag:+ if branch != config.main_branch and branch_state.latest_tag != source_tag:+ write_output("should_build", "false")+ write_output(+ "skip_reason",+ f"Tag `{source_tag}` is no longer the newest release tag on `{branch}`.",+ )+ return+ if branch == config.main_branch and branch_state.latest_tag != source_tag:+ publish_branch_tag = False+ if publish_branch_tag and not docker_tag_exists(config.image_repo, mutable_tag):+ tags_to_push.append(f"{config.image_repo}:{mutable_tag}")+ else:+ fail(f"Unsupported resolve-build mode: {mode}")++ tags_to_push = unique(tags_to_push)+ if not tags_to_push:+ write_output("should_build", "false")+ write_output("skip_reason", "All requested Docker tags already exist or are no longer eligible.")+ return++ write_output("should_build", "true")+ write_output("tags", "\n".join(tags_to_push))+ write_output("display_tags", ", ".join(tag.rsplit(":", 1)[1] for tag in tags_to_push))+ print("\n".join(tags_to_push))+++def main() -> None:+ if len(sys.argv) != 2:+ fail("Usage: docker_release_plan.py <plan|resolve-build|resolve-release>")++ command = sys.argv[1]+ if command == "plan":+ plan_command()+ return+ if command == "resolve-build":+ resolve_build_command()+ return+ if command == "resolve-release":+ resolve_release_command()+ return+ fail(f"Unknown command: {command}")+++if __name__ == "__main__":+ main()diff --git a/.github/workflows/close-inactive.yml b/.github/workflows/close-inactive.ymlnew file mode 100644index 000000000..0d8fcb00d--- /dev/null+++ b/.github/workflows/close-inactive.yml@@ -0,0 +1,108 @@+name: Close inactive issues and PRs++on:+ schedule:+ - cron: "17 3 * * *"+ workflow_dispatch:+ inputs:+ inactive_days:+ description: "Close items with no activity for more than N days"+ required: false+ default: "90"+ dry_run:+ description: "If true, only print URLs (no comment/close)"+ required: false+ default: "true"++permissions:+ issues: write+ pull-requests: write++env:+ DEFAULT_INACTIVE_DAYS: "90"+ DEFAULT_DRY_RUN: "true"++jobs:+ close_inactive:+ if: github.repository == 'agent0ai/agent-zero' && github.ref == format('refs/heads/{0}', github.event.repository.default_branch)+ runs-on: ubuntu-latest+ steps:+ - name: Find and optionally close inactive issues/PRs+ uses: actions/github-script@v7+ env:+ INACTIVE_DAYS: ${{ github.event_name == 'workflow_dispatch' && inputs.inactive_days || env.DEFAULT_INACTIVE_DAYS }}+ DRY_RUN: ${{ github.event_name == 'workflow_dispatch' && inputs.dry_run || env.DEFAULT_DRY_RUN }}+ with:+ script: |+ const inactiveDaysRaw = process.env.INACTIVE_DAYS ?? "90";+ const inactiveDays = Number.parseInt(inactiveDaysRaw, 10);+ if (!Number.isFinite(inactiveDays) || inactiveDays <= 0) {+ core.setFailed(`Invalid INACTIVE_DAYS: ${inactiveDaysRaw}`);+ return;+ }++ const dryRunRaw = (process.env.DRY_RUN ?? "true").toLowerCase();+ const dryRun = ["1", "true", "yes", "y"].includes(dryRunRaw);++ const now = new Date();+ const cutoff = new Date(now.getTime() - inactiveDays * 24 * 60 * 60 * 1000);+ const cutoffDate = cutoff.toISOString().slice(0, 10);++ core.info(`inactiveDays=${inactiveDays}`);+ core.info(`dryRun=${dryRun}`);+ core.info(`cutoffDate=${cutoffDate}`);++ const owner = context.repo.owner;+ const repo = context.repo.repo;++ async function processQuery(kind, searchQuery) {+ core.info(`Searching ${kind}: ${searchQuery}`);++ const items = await github.paginate(github.rest.search.issuesAndPullRequests, {+ q: searchQuery,+ per_page: 100,+ });++ if (items.length === 0) {+ core.info(`No inactive ${kind} found.`);+ return;+ }++ core.info(`Found ${items.length} inactive ${kind}. URLs:`);+ for (const item of items) {+ core.info(item.html_url);+ }++ if (dryRun) {+ return;+ }++ for (const item of items) {+ const issueNumber = item.number;+ const url = item.html_url;++ try {+ await github.rest.issues.createComment({+ owner,+ repo,+ issue_number: issueNumber,+ body: `Closing due to inactivity of ${inactiveDays} days.`,+ });++ await github.rest.issues.update({+ owner,+ repo,+ issue_number: issueNumber,+ state: "closed",+ });++ core.info(`Closed: ${url}`);+ } catch (err) {+ core.warning(`Failed to close ${url}: ${err?.message ?? String(err)}`);+ }+ }+ }++ const base = `repo:${owner}/${repo} is:open updated:<${cutoffDate}`;+ await processQuery("issues", `${base} is:issue`);+ await processQuery("pull requests", `${base} is:pr`);diff --git a/.github/workflows/docker-publish.yml b/.github/workflows/docker-publish.ymlnew file mode 100644index 000000000..003b220e5--- /dev/null+++ b/.github/workflows/docker-publish.yml@@ -0,0 +1,236 @@+name: Build And Publish Docker Images++on:+ push:+ branches:+ - "testing"+ - "ready"+ - "main"+ tags:+ - "v*"+ workflow_dispatch:+ inputs:+ tag:+ description: "Optional release tag to rebuild, for example v1.21"+ required: false+ type: string++env:+ # Non-main branches publish a Docker tag with the same name as the branch.+ ALLOWED_BRANCHES: "testing ready main"+ MAIN_BRANCH: "main"+ RELEASE_TAG_REGEX: "^v([0-9]+)\\.([0-9]+)$"+ MIN_RELEASE_MAJOR: "1"+ MIN_RELEASE_MINOR: "0"+ RELEASE_NOTES_DIR: "docs/release_notes"+ DOCKERFILE_DIR: "docker/run"+ DOCKERFILE_PATH: "docker/run/Dockerfile"+ DOCKER_IMAGE_NAME: "agent-zero"+ DOCKER_PLATFORMS: "linux/amd64,linux/arm64"++permissions:+ contents: read++jobs:+ plan:+ if: github.repository == 'agent0ai/agent-zero'+ runs-on: ubuntu-latest+ outputs:+ has_work: ${{ steps.plan.outputs.has_work }}+ matrix: ${{ steps.plan.outputs.matrix }}+ steps:+ - name: Validate Docker Hub secrets+ env:+ DOCKERHUB_ORG: ${{ secrets.DOCKERHUB_ORG }}+ DOCKERHUB_OAT_TOKEN: ${{ secrets.DOCKERHUB_OAT_TOKEN }}+ run: |+ if [[ -z "$DOCKERHUB_ORG" || -z "$DOCKERHUB_OAT_TOKEN" ]]; then+ echo "::error::Missing DOCKERHUB_ORG or DOCKERHUB_OAT_TOKEN secret."+ exit 1+ fi++ - name: Check out repository+ uses: actions/checkout@v4+ with:+ fetch-depth: 0++ - name: Fetch remote branches and tags+ run: git fetch --force --tags origin '+refs/heads/*:refs/remotes/origin/*'++ - name: Set up Docker Buildx+ uses: docker/setup-buildx-action@v3++ - name: Log in to Docker Hub+ uses: docker/login-action@v3+ with:+ username: ${{ secrets.DOCKERHUB_ORG }}+ password: ${{ secrets.DOCKERHUB_OAT_TOKEN }}++ - name: Plan Docker publish targets+ id: plan+ env:+ EVENT_NAME: ${{ github.event_name }}+ SOURCE_REF_NAME: ${{ github.ref_name }}+ SOURCE_REF_TYPE: ${{ github.ref_type }}+ BEFORE_SHA: ${{ github.event_name == 'push' && github.event.before || '' }}+ AFTER_SHA: ${{ github.event_name == 'push' && github.sha || '' }}+ MANUAL_TAG: ${{ github.event_name == 'workflow_dispatch' && github.event.inputs.tag || '' }}+ DOCKER_IMAGE_REPO: ${{ format('{0}/{1}', secrets.DOCKERHUB_ORG, env.DOCKER_IMAGE_NAME) }}+ run: python3 .github/scripts/docker_release_plan.py plan++ build:+ if: needs.plan.outputs.has_work == 'true'+ needs: plan+ runs-on: ubuntu-latest+ permissions:+ contents: write+ strategy:+ fail-fast: false+ matrix: ${{ fromJson(needs.plan.outputs.matrix) }}+ concurrency:+ group: docker-publish-${{ github.repository }}-${{ matrix.branch }}+ cancel-in-progress: false+ steps:+ - name: Check out repository+ uses: actions/checkout@v4+ with:+ fetch-depth: 0+ ref: ${{ matrix.source_tag }}++ - name: Fetch remote branches and tags+ run: git fetch --force --tags origin '+refs/heads/*:refs/remotes/origin/*'++ - name: Validate Docker Hub secrets+ env:+ DOCKERHUB_ORG: ${{ secrets.DOCKERHUB_ORG }}+ DOCKERHUB_OAT_TOKEN: ${{ secrets.DOCKERHUB_OAT_TOKEN }}+ run: |+ if [[ -z "$DOCKERHUB_ORG" || -z "$DOCKERHUB_OAT_TOKEN" ]]; then+ echo "::error::Missing DOCKERHUB_ORG or DOCKERHUB_OAT_TOKEN secret."+ exit 1+ fi++ - name: Set up QEMU+ uses: docker/setup-qemu-action@v3++ - name: Set up Docker Buildx+ uses: docker/setup-buildx-action@v3++ - name: Log in to Docker Hub+ uses: docker/login-action@v3+ with:+ username: ${{ secrets.DOCKERHUB_ORG }}+ password: ${{ secrets.DOCKERHUB_OAT_TOKEN }}++ - name: Re-resolve Docker tags for this build+ id: resolve+ env:+ EVENT_NAME: ${{ github.event_name }}+ SOURCE_REF_NAME: ${{ github.ref_name }}+ SOURCE_REF_TYPE: ${{ github.ref_type }}+ BEFORE_SHA: ${{ github.event_name == 'push' && github.event.before || '' }}+ AFTER_SHA: ${{ github.event_name == 'push' && github.sha || '' }}+ MANUAL_TAG: ${{ github.event_name == 'workflow_dispatch' && github.event.inputs.tag || '' }}+ DOCKER_IMAGE_REPO: ${{ format('{0}/{1}', secrets.DOCKERHUB_ORG, env.DOCKER_IMAGE_NAME) }}+ TARGET_BRANCH: ${{ matrix.branch }}+ TARGET_TAG: ${{ matrix.source_tag }}+ TARGET_MODE: ${{ matrix.mode }}+ TARGET_PUBLISH_VERSION: ${{ matrix.publish_version }}+ TARGET_PUBLISH_BRANCH_TAG: ${{ matrix.publish_branch_tag }}+ run: python3 .github/scripts/docker_release_plan.py resolve-build++ - name: Skip when target is no longer eligible+ if: steps.resolve.outputs.should_build != 'true'+ run: echo "${{ steps.resolve.outputs.skip_reason }}"++ - name: Set cache date+ if: steps.resolve.outputs.should_build == 'true'+ id: cache_date+ run: echo "value=$(date -u +%Y-%m-%d:%H:%M:%S)" >> "$GITHUB_OUTPUT"++ - name: Build and push Docker image+ if: steps.resolve.outputs.should_build == 'true'+ uses: docker/build-push-action@v6+ with:+ context: ${{ env.DOCKERFILE_DIR }}+ file: ${{ env.DOCKERFILE_PATH }}+ platforms: ${{ env.DOCKER_PLATFORMS }}+ push: true+ tags: ${{ steps.resolve.outputs.tags }}+ build-args: |+ BRANCH=${{ matrix.branch }}+ CACHE_DATE=${{ steps.cache_date.outputs.value }}++ - name: Resolve GitHub release target+ if: steps.resolve.outputs.should_build == 'true'+ id: release_plan+ env:+ EVENT_NAME: ${{ github.event_name }}+ SOURCE_REF_NAME: ${{ github.ref_name }}+ SOURCE_REF_TYPE: ${{ github.ref_type }}+ BEFORE_SHA: ${{ github.event_name == 'push' && github.event.before || '' }}+ AFTER_SHA: ${{ github.event_name == 'push' && github.sha || '' }}+ MANUAL_TAG: ${{ github.event_name == 'workflow_dispatch' && github.event.inputs.tag || '' }}+ DOCKER_IMAGE_REPO: ${{ format('{0}/{1}', secrets.DOCKERHUB_ORG, env.DOCKER_IMAGE_NAME) }}+ TARGET_BRANCH: ${{ matrix.branch }}+ TARGET_TAG: ${{ matrix.source_tag }}+ RELEASE_NOTES_DIR: ${{ env.RELEASE_NOTES_DIR }}+ run: python3 .github/scripts/docker_release_plan.py resolve-release++ - name: Skip GitHub release+ if: steps.resolve.outputs.should_build == 'true' && steps.release_plan.outputs.should_release != 'true'+ run: echo "${{ steps.release_plan.outputs.skip_reason }}"++ - name: Create or update GitHub release+ if: steps.resolve.outputs.should_build == 'true' && steps.release_plan.outputs.should_release == 'true'+ uses: actions/github-script@v7+ env:+ RELEASE_TAG: ${{ steps.release_plan.outputs.release_tag }}+ RELEASE_NAME: ${{ steps.release_plan.outputs.release_name }}+ RELEASE_BODY: ${{ steps.release_plan.outputs.release_body }}+ with:+ script: |+ const owner = context.repo.owner;+ const repo = context.repo.repo;+ const tag = process.env.RELEASE_TAG;+ const name = process.env.RELEASE_NAME;+ const body = process.env.RELEASE_BODY;++ try {+ const existing = await github.rest.repos.getReleaseByTag({+ owner,+ repo,+ tag,+ });++ await github.rest.repos.updateRelease({+ owner,+ repo,+ release_id: existing.data.id,+ tag_name: tag,+ name,+ body,+ draft: false,+ prerelease: false,+ make_latest: "true",+ });++ core.info(`Updated release ${tag}`);+ } catch (error) {+ if (error.status !== 404) {+ throw error;+ }++ await github.rest.repos.createRelease({+ owner,+ repo,+ tag_name: tag,+ name,+ body,+ draft: false,+ prerelease: false,+ make_latest: "true",+ });++ core.info(`Created release ${tag}`);+ }