"""Multi-arch image build + push to Docker Hub, GHCR, and Gitea.""" from __future__ import annotations import argparse import getpass import json import os import platform as py_platform import re import subprocess import sys import urllib.error import urllib.request from collections.abc import Mapping from dataclasses import dataclass from pathlib import Path import yaml from rich.prompt import Prompt from deploy.docker_local import BUILDER_NAME, ensure_buildx, ensure_daemon from deploy.paths import ProjectPaths import deploy.ui as ui PLATFORMS = "linux/amd64,linux/arm64" SEMVER_TAG = re.compile(r"^v\d+\.\d+(?:\.\d+)?$") LATEST_TAG = "latest" GHCR_HOST = "ghcr.io" GITEA_HOST = "git.fromchat.ru" DOCKERHUB_HOST = "docker.io" # Always publish container images to GitHub Packages + Gitea unless --no-push. DEFAULT_PUSH_REGISTRIES = ("github", "gitea") SECRETS_DIRNAME = ".secrets" SECRETS_FILENAME = "registry.env" PUBLISH_SETTINGS_FILENAME = "publish.json" PUBLISH_SETTINGS_VERSION = 1 @dataclass(frozen=True) class ImageSpec: """One fromchat/* image discovered from a compose build block.""" service: str repo_root: Path context: Path dockerfile: Path target: str | None = None build_args: tuple[tuple[str, str], ...] = () @dataclass(frozen=True) class Registry: name: str host: str image_tpl: str user_key: str token_key: str default_user: str prompt_label: str REGISTRIES: dict[str, Registry] = { "dockerhub": Registry( name="dockerhub", host=DOCKERHUB_HOST, image_tpl="fromchat/{service}", user_key="DOCKERHUB_USERNAME", token_key="DOCKERHUB_TOKEN", default_user="fromchat", prompt_label="Docker Hub", ), "github": Registry( name="github", host=GHCR_HOST, image_tpl="ghcr.io/fromchat-messenger/{service}", user_key="GHCR_USERNAME", token_key="GHCR_TOKEN", default_user="fromchat-messenger", prompt_label="GitHub Packages (ghcr.io)", ), "gitea": Registry( name="gitea", host=GITEA_HOST, image_tpl="git.fromchat.ru/fromchat/{service}", user_key="GITEA_USERNAME", token_key="GITEA_TOKEN", default_user="fromchat", prompt_label="Gitea (git.fromchat.ru)", ), } @dataclass class Creds: user: str token: str def secrets_dir(paths: ProjectPaths) -> Path: return paths.deployment_root / SECRETS_DIRNAME def secrets_file(paths: ProjectPaths) -> Path: return secrets_dir(paths) / SECRETS_FILENAME def publish_settings_file(paths: ProjectPaths) -> Path: return secrets_dir(paths) / PUBLISH_SETTINGS_FILENAME def _parse_env_file(path: Path) -> dict[str, str]: out: dict[str, str] = {} if not path.is_file(): return out for raw in path.read_text(encoding="utf-8", errors="replace").splitlines(): line = raw.strip() if not line or line.startswith("#") or "=" not in line: continue key, _, val = line.partition("=") key = key.strip() val = val.strip() if len(val) >= 2 and val[0] == val[-1] and val[0] in ("\"", "'"): val = val[1:-1] if key: out[key] = val return out def _quote_env_value(val: str) -> str: if any(ch in val for ch in ' \t#"\'\\$`'): esc = val.replace("\\", "\\\\").replace('"', '\\"') return f'"{esc}"' return val def load_saved_secrets(paths: ProjectPaths) -> dict[str, str]: return _parse_env_file(secrets_file(paths)) def save_secrets(paths: ProjectPaths, values: dict[str, str]) -> None: existing = load_saved_secrets(paths) existing.update({k: v for k, v in values.items() if v}) d = secrets_dir(paths) d.mkdir(parents=True, exist_ok=True) try: d.chmod(0o700) except OSError: pass lines = [ "# FromChat publish registry credentials — do not commit", "# Written by deployment/scripts/deploy/publish.py", "", ] for key in sorted(existing): # Always quote token values — PATs can contain characters that break bare env parsing. if key.endswith("_TOKEN") or key.endswith("_PASSWORD"): esc = existing[key].replace("\\", "\\\\").replace('"', '\\"') lines.append(f'{key}="{esc}"') else: lines.append(f"{key}={_quote_env_value(existing[key])}") path = secrets_file(paths) tmp = path.with_suffix(path.suffix + ".tmp") tmp.write_text("\n".join(lines) + "\n", encoding="utf-8") tmp.replace(path) try: path.chmod(0o600) except OSError: pass try: shown = path.relative_to(paths.deployment_root) except ValueError: shown = path ui.substep(f"Saved credentials → {shown}") def load_publish_settings(paths: ProjectPaths) -> dict[str, object] | None: path = publish_settings_file(paths) if not path.is_file(): return None try: data = json.loads(path.read_text(encoding="utf-8")) except (OSError, json.JSONDecodeError): return None if not isinstance(data, dict) or data.get("version") != PUBLISH_SETTINGS_VERSION: return None return data def save_publish_settings( paths: ProjectPaths, *, registries: list[str], ) -> None: d = secrets_dir(paths) d.mkdir(parents=True, exist_ok=True) try: d.chmod(0o700) except OSError: pass payload = { "version": PUBLISH_SETTINGS_VERSION, "registries": registries, } path = publish_settings_file(paths) path.write_text(json.dumps(payload, indent=2) + "\n", encoding="utf-8") try: path.chmod(0o600) except OSError: pass ui.substep(f"Saved registry choices → {path.relative_to(paths.deployment_root)}") def _load_compose(path: Path) -> dict: with path.open(encoding="utf-8") as fh: data = yaml.safe_load(fh) or {} if not isinstance(data, dict): raise ValueError(f"{path}: root must be a mapping") return data def _expand_compose_value(raw: str, env: Mapping[str, str] | None = None) -> str: """Expand Compose-style `${VAR}`, `${VAR:-default}`, and `$VAR` interpolations.""" environ = env if env is not None else os.environ def repl(match: re.Match[str]) -> str: braced = match.group(1) if braced is not None: name = braced default = match.group(2) value = environ.get(name) if value is not None and value != "": return value if default is not None: return default return "" name = match.group(3) return environ.get(name, "") if name else match.group(0) return re.sub( r"\$\{([A-Za-z_][A-Za-z0-9_]*)(?::-([^}]*))?\}|\$([A-Za-z_][A-Za-z0-9_]*)", repl, raw, ) def _resolve_build_paths(compose_dir: Path, build: dict | str) -> tuple[Path, Path, str | None, tuple[tuple[str, str], ...]]: if isinstance(build, str): build = {"context": build} if not isinstance(build, dict): raise ValueError("compose build must be a mapping or string") context_rel = str(build.get("context") or ".").strip() if context_rel in (".", "./", ""): context = compose_dir.resolve() elif context_rel.startswith("./"): context = (compose_dir / context_rel[2:]).resolve() else: context = (compose_dir / context_rel).resolve() dockerfile_rel = str(build.get("dockerfile") or "Dockerfile").strip() dockerfile = Path(dockerfile_rel) if not dockerfile.is_absolute(): dockerfile = context / dockerfile target = build.get("target") target_str = str(target).strip() if target else None args_raw = build.get("args") or {} build_args: list[tuple[str, str]] = [] if isinstance(args_raw, dict): for key, val in args_raw.items(): if val is None: continue build_args.append((str(key), _expand_compose_value(str(val)))) return context, dockerfile.resolve(), target_str, tuple(build_args) def discover_image_specs(paths: ProjectPaths) -> list[ImageSpec]: """Collect every compose service with a build: block across backend, web, updater.""" compose_files: list[tuple[Path, Path]] = [] if paths.backend_dir and (paths.backend_dir / "compose.yml").is_file(): compose_files.append((paths.backend_dir, paths.backend_dir / "compose.yml")) prod_compose = paths.backend_dir / "compose.prod.yml" if prod_compose.is_file(): compose_files.append((paths.backend_dir, prod_compose)) if paths.web_dir and (paths.web_dir / "compose.yml").is_file(): compose_files.append((paths.web_dir, paths.web_dir / "compose.yml")) if paths.admin_dir and (paths.admin_dir / "compose.yml").is_file(): compose_files.append((paths.admin_dir, paths.admin_dir / "compose.yml")) if paths.updater_dir and (paths.updater_dir / "compose.yml").is_file(): compose_files.append((paths.updater_dir, paths.updater_dir / "compose.yml")) if not compose_files: ui.error("No compose.yml found in backend, web, admin, or updater repos.") raise SystemExit(1) specs: list[ImageSpec] = [] seen: set[str] = set() for repo_root, compose_path in compose_files: doc = _load_compose(compose_path) services = doc.get("services") or {} if not isinstance(services, dict): continue for name, cfg in services.items(): if not isinstance(cfg, dict) or "build" not in cfg: continue if name in seen: ui.error(f"Duplicate publishable service name: {name}") raise SystemExit(1) seen.add(name) context, dockerfile, target, build_args = _resolve_build_paths( compose_path.parent, cfg["build"] ) specs.append( ImageSpec( service=name, repo_root=repo_root, context=context, dockerfile=dockerfile, target=target, build_args=build_args, ) ) if not specs: ui.error("No services with build: blocks found in compose files.") raise SystemExit(1) return sorted(specs, key=lambda s: s.service) def _confirm(prompt: str, *, default: bool = True) -> bool: """Block for real TTY input — Rich Confirm can accept defaults without a keypress.""" if not sys.stdin.isatty() or not sys.stdout.isatty(): return default suffix = "Y/n" if default else "y/N" try: answer = input(f" {prompt} [{suffix}]: ").strip().lower() except EOFError: return default if not answer: return default if answer in ("y", "yes"): return True if answer in ("n", "no"): return False return default def parse_services_csv(raw: str, allowed: set[str]) -> list[str]: out: list[str] = [] for part in raw.split(","): name = part.strip() if not name: continue if name not in allowed: ui.error(f"Unknown service: {name} (available: {', '.join(sorted(allowed))})") raise SystemExit(1) if name not in out: out.append(name) if not out: ui.error("Select at least one service.") raise SystemExit(1) return out def prompt_services_interactive(specs: list[ImageSpec]) -> list[str]: """Ask which images to publish. Selection is not persisted.""" ui.step("Services to publish") ui.info("Not remembered — select every time (or pass --services).") selected: list[str] = [] for spec in specs: label = f"{spec.service} ({spec.repo_root.name})" if _confirm(f"Publish {label}?", default=True): selected.append(spec.service) ui.substep(f"include → {spec.service}") else: ui.substep(f"skip → {spec.service}") if not selected: ui.error("No services selected.") raise SystemExit(1) return selected def git_fetch_tags(repo: Path) -> None: """Update local tags from remotes without rewriting other refs.""" subprocess.run( ["git", "fetch", "--tags"], cwd=repo, capture_output=True, text=True, ) def git_tag_at_head(repo: Path) -> str: p = subprocess.run( ["git", "tag", "--points-at", "HEAD"], cwd=repo, capture_output=True, text=True, ) if p.returncode != 0: ui.error(f"git tag --points-at HEAD failed in {repo}: {p.stderr.strip()}") raise SystemExit(1) tags = [t.strip() for t in p.stdout.splitlines() if t.strip()] if not tags: ui.error( f"No git tag on HEAD in {repo}. " "Publish tags match the component's current commit tag — create/checkout a tag first." ) raise SystemExit(1) semver = [t for t in tags if SEMVER_TAG.match(t)] if semver: semver.sort(key=lambda t: [int(x) for x in t.lstrip("v").split(".")]) return semver[-1] tags.sort() return tags[-1] def git_source_url(repo: Path) -> str: p = subprocess.run( ["git", "remote", "get-url", "origin"], cwd=repo, capture_output=True, text=True, ) if p.returncode != 0: return "" raw = p.stdout.strip() if not raw: return "" if raw.startswith("git@"): host_path = raw[4:] if ":" in host_path: host, path = host_path.split(":", 1) return f"https://{host}/{path.removesuffix('.git')}" return "" if raw.startswith("http://") or raw.startswith("https://"): return raw.removesuffix(".git") return "" def git_sha(repo: Path) -> str: p = subprocess.run( ["git", "rev-parse", "HEAD"], cwd=repo, capture_output=True, text=True, ) if p.returncode != 0: return "" return p.stdout.strip() def repo_readme(repo_root: Path) -> str: for name in ("README.md", "README.en.md", "README"): path = repo_root / name if path.is_file(): return path.read_text(encoding="utf-8", errors="replace").strip() return "" def readme_summary(readme: str, *, max_len: int = 100) -> str: if not readme: return "" for line in readme.splitlines(): text = line.strip() if not text: continue if text.startswith("#"): text = text.lstrip("#").strip() if text: return text[:max_len] return "" def _resolve_tags(specs: list[ImageSpec]) -> dict[Path, str]: repos: dict[Path, str] = {} for spec in specs: if spec.repo_root not in repos: git_fetch_tags(spec.repo_root) tag = git_tag_at_head(spec.repo_root) repos[spec.repo_root] = tag ui.substep(f"{spec.repo_root.name}: {tag}") return repos def _parse_push_list(raw: str | None) -> list[str] | None: if raw is None: return None raw = raw.strip().lower() if raw in ("", "none", "false", "0"): return [] if raw in ("all", "true", "1"): return list(REGISTRIES) out: list[str] = [] for part in raw.split(","): name = part.strip().lower() if not name: continue if name in ("ghcr", "github-packages", "gh"): name = "github" if name in ("hub", "docker"): name = "dockerhub" if name not in REGISTRIES: ui.error( f"Unknown registry: {part!r} " f"(allowed: {', '.join(sorted(REGISTRIES))}, or all)" ) raise SystemExit(1) if name not in out: out.append(name) return out def _registry_labels() -> dict[str, str]: return { "dockerhub": "Docker Hub (fromchat/*)", "github": "GitHub Packages (ghcr.io/fromchat-messenger/*)", "gitea": "Gitea (git.fromchat.ru/fromchat/*)", } def _ensure_default_push_registries(regs: list[str]) -> list[str]: """GitHub + Gitea are always included when publishing (Docker Hub stays optional).""" out = list(regs) for name in DEFAULT_PUSH_REGISTRIES: if name not in out: out.append(name) return out def _select_registries_interactive(saved: dict[str, object] | None) -> list[str]: ui.step("Push destinations") ui.info( f"Credentials are asked here and saved under {SECRETS_DIRNAME}/{SECRETS_FILENAME} " "(gitignored). GitHub Packages and Gitea are always included." ) saved_regs = saved.get("registries") if isinstance(saved, dict) else None saved_set = set(saved_regs) if isinstance(saved_regs, list) else set() has_saved = bool(saved_set) selected: list[str] = list(DEFAULT_PUSH_REGISTRIES) labels = _registry_labels() for name in DEFAULT_PUSH_REGISTRIES: ui.substep(f"{labels[name]} — always") default_hub = "dockerhub" in saved_set if has_saved else False if _confirm(f"Also push to {labels['dockerhub']}?", default=default_hub): selected.append("dockerhub") return selected def _saved_registries(saved: dict[str, object] | None) -> list[str]: if not isinstance(saved, dict): return [] regs = saved.get("registries") if not isinstance(regs, list): return [] out: list[str] = [] for name in regs: if isinstance(name, str) and name in REGISTRIES and name not in out: out.append(name) return out def _prompt_creds( registry: Registry, saved: dict[str, str], *, force_prompt: bool = False, ) -> Creds | None: saved_user = ( os.environ.get(registry.user_key) or saved.get(registry.user_key) or "" ).strip() saved_token = ( os.environ.get(registry.token_key) or saved.get(registry.token_key) or "" ).strip() default_user = saved_user or registry.default_user if not force_prompt and saved_user and saved_token: ui.substep(f"{registry.prompt_label}: using saved credentials (user={saved_user})") return Creds(user=saved_user, token=saved_token) if not sys.stdin.isatty(): ui.warning( f"Missing {registry.prompt_label} credentials (no TTY) — skipping. " f"Set them in {SECRETS_DIRNAME}/{SECRETS_FILENAME}." ) return None ui.substep(f"{registry.prompt_label} credentials") user = Prompt.ask(f" {registry.prompt_label} username", default=default_user).strip() if not user: ui.warning(f"{registry.prompt_label} username empty — skipping") return None if not force_prompt and saved_token and saved_user == user: token = saved_token ui.substep(f"{registry.prompt_label}: reusing saved token") else: token = getpass.getpass( f" {registry.prompt_label} token / password (hidden): " ).strip() if not token: ui.warning(f"{registry.prompt_label} token empty — skipping") return None return Creds(user=user, token=token) def _docker_login(registry: Registry, creds: Creds) -> bool: ui.substep(f"docker login {registry.host} (user={creds.user})") p = subprocess.run( ["docker", "login", registry.host, "-u", creds.user, "--password-stdin"], input=creds.token, text=True, capture_output=True, ) if p.returncode != 0: detail = (p.stderr or p.stdout or "").strip() ui.warning(f"docker login failed for {registry.host}: {detail}") return False return True def _persist_creds( paths: ProjectPaths, saved: dict[str, str], registry: Registry, creds: Creds, ) -> None: save_secrets( paths, { registry.user_key: creds.user, registry.token_key: creds.token, }, ) saved[registry.user_key] = creds.user saved[registry.token_key] = creds.token def collect_and_login(names: list[str], paths: ProjectPaths) -> dict[str, Creds]: if not names: return {} ui.step("Registry credentials") saved = load_saved_secrets(paths) secrets_path = secrets_file(paths) if secrets_path.is_file(): try: shown = secrets_path.relative_to(paths.deployment_root) except ValueError: shown = secrets_path ui.info(f"Loaded saved secrets from {shown}") creds_map: dict[str, Creds] = {} skipped: list[str] = [] for name in names: registry = REGISTRIES[name] had_saved = bool( (saved.get(registry.user_key) or "").strip() and (saved.get(registry.token_key) or "").strip() ) creds = _prompt_creds(registry, saved) if creds is None: skipped.append(name) continue # Always persist before login — failed logins must still remember what was typed. _persist_creds(paths, saved, registry, creds) if _docker_login(registry, creds): creds_map[name] = creds continue if had_saved and sys.stdin.isatty() and _confirm( f"Re-enter {registry.prompt_label} credentials?", default=True, ): creds = _prompt_creds(registry, saved, force_prompt=True) if creds is not None: _persist_creds(paths, saved, registry, creds) if _docker_login(registry, creds): creds_map[name] = creds continue skipped.append(name) if skipped: ui.warning("Skipped registries after login/credential failures: " + ", ".join(skipped)) if creds_map: ui.success("Logged in: " + ", ".join(creds_map)) elif names: ui.error("All registry logins failed.") raise SystemExit(1) return creds_map def _ref_for(registry: Registry, service: str, tag: str) -> str: return f"{registry.image_tpl.format(service=service)}:{tag}" def _publish_tags(version_tag: str) -> list[str]: """Version tag plus `latest` (unless the version is already latest).""" if version_tag == LATEST_TAG: return [LATEST_TAG] return [version_tag, LATEST_TAG] def _native_platform() -> str: machine = py_platform.machine().lower() if machine in ("x86_64", "amd64"): return "linux/amd64" if machine in ("aarch64", "arm64"): return "linux/arm64" return "linux/amd64" def _oci_labels( spec: ImageSpec, tag: str, revision: str, source_url: str, ) -> list[tuple[str, str]]: readme = repo_readme(spec.repo_root) desc = readme_summary(readme) or f"FromChat {spec.service}" labels = [ ("org.opencontainers.image.title", f"fromchat/{spec.service}"), ("org.opencontainers.image.description", desc), ("org.opencontainers.image.version", tag), ("org.opencontainers.image.vendor", "FromChat"), ] if source_url: labels.extend( [ ("org.opencontainers.image.source", source_url), ("org.opencontainers.image.url", source_url), ] ) if revision: labels.append(("org.opencontainers.image.revision", revision)) return labels def _local_image_ref(service: str, tag: str) -> str: return f"fromchat/{service}:{tag}" def _local_image_exists(ref: str) -> bool: return ( subprocess.run( ["docker", "image", "inspect", ref], capture_output=True, ).returncode == 0 ) def _tag_local(src: str, dest: str) -> bool: p = subprocess.run( ["docker", "tag", src, dest], capture_output=True, text=True, ) if p.returncode != 0: detail = (p.stderr or p.stdout or "").strip() ui.warning(f"docker tag {src} → {dest} failed: {detail}") return False return True def _ensure_local_latest(service: str, version_tag: str) -> None: """Point fromchat/:latest at the version image when present.""" if version_tag == LATEST_TAG: return src = _local_image_ref(service, version_tag) dest = _local_image_ref(service, LATEST_TAG) if not _local_image_exists(src): return if _tag_local(src, dest): ui.substep(f"local → {dest}") def _push_one_local( spec: ImageSpec, tag: str, *, push_to: list[str], ) -> list[str]: """Retag a local fromchat/* image and push version + latest to each registry. Returns the registry names that succeeded (at least one tag pushed). """ local_ref = _local_image_ref(spec.service, tag) ui.step(f"Push {spec.service}:{tag} (+ {LATEST_TAG}) (local image, no rebuild)") if not _local_image_exists(local_ref): ui.error( f"Local image missing: {local_ref}. " "Build first (omit --no-build) or load the image into Docker." ) raise SystemExit(1) ui.substep(f"source → {local_ref}") _ensure_local_latest(spec.service, tag) ok: list[str] = [] for reg_name in push_to: registry = REGISTRIES[reg_name] pushed_any = False for t in _publish_tags(tag): remote = _ref_for(registry, spec.service, t) ui.substep(f"tag → {remote}") if not _tag_local(local_ref, remote): continue ui.substep(f"push → {remote}") if subprocess.run(["docker", "push", remote]).returncode != 0: ui.warning(f"docker push failed for {remote} — skipping tag") continue pushed_any = True if pushed_any: ok.append(reg_name) if ok: ui.success(f"{spec.service}:{tag} (+ {LATEST_TAG}) pushed → " + ", ".join(ok)) else: ui.warning(f"{spec.service}:{tag}: no registry accepted the push") return ok def _buildx_cmd( spec: ImageSpec, tags: list[str], *, revision: str, source_url: str, version_tag: str, platforms: str, mode: str, ) -> list[str]: """mode: 'push' | 'load' | 'cache'.""" cmd = [ "docker", "buildx", "build", "--builder", BUILDER_NAME, "--platform", platforms, "--file", str(spec.dockerfile), "--tag", tags[0], ] for extra in tags[1:]: cmd.extend(["--tag", extra]) if spec.target: cmd.extend(["--target", spec.target]) for key, val in spec.build_args: cmd.extend(["--build-arg", f"{key}={val}"]) for key, val in _oci_labels(spec, version_tag, revision, source_url): cmd.extend(["--label", f"{key}={val}"]) # Index annotations are only valid for multi-platform (registry) exports. if mode != "load": cmd.extend(["--annotation", f"index:{key}={val}"]) cmd.extend(["--annotation", f"manifest:{key}={val}"]) if mode == "push": cmd.append("--push") elif mode == "load": cmd.append("--load") else: cmd.extend(["--output", "type=image,push=false"]) cmd.append(str(spec.context)) return cmd def _load_local_native( spec: ImageSpec, version_tag: str, *, revision: str, source_url: str, ) -> None: """Load the host platform into the local Docker engine as :version and :latest.""" native = _native_platform() local_tags = [_local_image_ref(spec.service, t) for t in _publish_tags(version_tag)] ui.substep(f"local load ({native}) → " + ", ".join(local_tags)) cmd = _buildx_cmd( spec, local_tags, revision=revision, source_url=source_url, version_tag=version_tag, platforms=native, mode="load", ) if subprocess.run(cmd).returncode != 0: ui.warning( f"Could not load {spec.service} into the local Docker engine " f"(multi-arch push may still have succeeded)." ) return for ref in local_tags: ui.substep(f"local → {ref}") def _build_one( spec: ImageSpec, tag: str, *, push_to: list[str], ) -> list[str]: """Build multi-arch image; push version+latest per registry; keep native tags locally. Returns the registry names that were pushed successfully. """ revision = git_sha(spec.repo_root) source_url = git_source_url(spec.repo_root) local_preview = ", ".join( _local_image_ref(spec.service, t) for t in _publish_tags(tag) ) ui.step(f"Build {spec.service}:{tag} ({PLATFORMS})") if source_url: ui.substep(f"source → {source_url}") ui.substep(f"local targets → {local_preview}") if not push_to: # Multi-arch stays in the builder; also load native into Docker. cmd = _buildx_cmd( spec, [_local_image_ref(spec.service, t) for t in _publish_tags(tag)], revision=revision, source_url=source_url, version_tag=tag, platforms=PLATFORMS, mode="cache", ) if subprocess.run(cmd).returncode != 0: ui.error(f"buildx failed for {spec.service}") raise SystemExit(1) _load_local_native( spec, tag, revision=revision, source_url=source_url, ) ui.success(f"{spec.service}:{tag} ready locally (not pushed)") return [] ok: list[str] = [] for reg_name in push_to: registry = REGISTRIES[reg_name] remotes = [_ref_for(registry, spec.service, t) for t in _publish_tags(tag)] ui.substep("push → " + ", ".join(remotes)) cmd = _buildx_cmd( spec, remotes, revision=revision, source_url=source_url, version_tag=tag, platforms=PLATFORMS, mode="push", ) if subprocess.run(cmd).returncode != 0: ui.warning( f"buildx push failed for {registry.prompt_label} — skipping registry" ) continue ok.append(reg_name) # Always leave native platform images tagged in the local engine. _load_local_native( spec, tag, revision=revision, source_url=source_url, ) if ok: ui.success( f"{spec.service}:{tag} (+ {LATEST_TAG}) ready → " + ", ".join(ok) ) else: ui.warning(f"{spec.service}:{tag}: build/push failed for every registry") return ok def _http_json( method: str, url: str, *, headers: dict[str, str], body: dict | None = None, ) -> tuple[int, dict | list | None]: data = None req_headers = dict(headers) if body is not None: data = json.dumps(body).encode() req_headers.setdefault("Content-Type", "application/json") req = urllib.request.Request(url, data=data, headers=req_headers, method=method) try: with urllib.request.urlopen(req, timeout=30) as resp: raw = resp.read().decode() parsed = json.loads(raw) if raw.strip() else None return resp.status, parsed except urllib.error.HTTPError as e: raw = e.read().decode(errors="replace") try: parsed = json.loads(raw) if raw.strip() else None except json.JSONDecodeError: parsed = {"message": raw} return e.code, parsed def _dockerhub_jwt(user: str, token: str) -> str | None: status, data = _http_json( "POST", "https://hub.docker.com/v2/users/login/", headers={}, body={"username": user, "password": token}, ) if status != 200 or not isinstance(data, dict): return None jwt = data.get("token") return jwt if isinstance(jwt, str) and jwt else None def dockerhub_tag_exists(service: str, tag: str, jwt: str) -> bool | None: """Return True if the tag exists, False if not, None if the check failed.""" status, _ = _http_json( "GET", f"https://hub.docker.com/v2/repositories/fromchat/{service}/tags/{tag}/", headers={"Authorization": f"JWT {jwt}"}, ) if status == 200: return True if status == 404: return False return None def dockerhub_delete_tag(service: str, tag: str, jwt: str) -> bool: status, _ = _http_json( "DELETE", f"https://hub.docker.com/v2/repositories/fromchat/{service}/tags/{tag}/", headers={"Authorization": f"JWT {jwt}"}, ) return status in (200, 202, 204) def verify_dockerhub_tags_free( specs: list[ImageSpec], repo_tags: dict[Path, str], creds: Creds, ) -> bool: """Ensure planned Docker Hub tags are free (or deleted with confirmation). Returns False if Docker Hub should be skipped (check/delete failed). """ ui.step("Checking Docker Hub tags") jwt = _dockerhub_jwt(creds.user, creds.token) if not jwt: ui.warning("Docker Hub API login failed; skipping Docker Hub.") return False conflicts: list[tuple[str, str]] = [] errors: list[str] = [] seen: set[tuple[str, str]] = set() for spec in specs: tag = repo_tags[spec.repo_root] key = (spec.service, tag) if key in seen: continue seen.add(key) ref = f"fromchat/{spec.service}:{tag}" exists = dockerhub_tag_exists(spec.service, tag, jwt) if exists is True: conflicts.append(key) ui.substep(f"{ref} — already exists") elif exists is False: ui.substep(f"{ref} — free") else: errors.append(ref) ui.substep(f"{ref} — check failed") if errors: ui.warning( "Could not verify Docker Hub tags for: " + ", ".join(errors) + ". Skipping Docker Hub." ) return False if conflicts: conflict_refs = [f"fromchat/{service}:{tag}" for service, tag in conflicts] ui.warning( "These Docker Hub tags already exist:\n " + "\n ".join(conflict_refs) ) if not sys.stdin.isatty() or not sys.stdout.isatty(): ui.warning( "Refusing to overwrite existing Docker Hub tags non-interactively — " "skipping Docker Hub." ) return False if not _confirm( f"Delete all {len(conflicts)} conflicting tag(s) on Docker Hub and continue?", default=False, ): ui.warning("Skipping Docker Hub — conflicting tags were not deleted.") return False ui.substep("Deleting conflicting Docker Hub tags") failed: list[str] = [] for service, tag in conflicts: ref = f"fromchat/{service}:{tag}" if dockerhub_delete_tag(service, tag, jwt): ui.substep(f"{ref} — deleted") else: failed.append(ref) ui.substep(f"{ref} — delete failed") if failed: ui.warning( "Could not delete Docker Hub tags:\n " + "\n ".join(failed) + "\nSkipping Docker Hub." ) return False still_there: list[str] = [] for service, tag in conflicts: if dockerhub_tag_exists(service, tag, jwt): still_there.append(f"fromchat/{service}:{tag}") if still_there: ui.warning( "Docker Hub tags still present after delete:\n " + "\n ".join(still_there) + "\nSkipping Docker Hub." ) return False ui.success(f"Deleted {len(conflicts)} conflicting Docker Hub tag(s)") return True ui.success("Docker Hub tags are free") return True def bind_dockerhub_repo(service: str, repo_root: Path, creds: Creds) -> None: jwt = _dockerhub_jwt(creds.user, creds.token) if not jwt: ui.warning(f"Docker Hub API login failed; skip repo bind for {service}") return readme = repo_readme(repo_root) if not readme: ui.warning(f"No README in {repo_root.name}; skip Docker Hub overview for {service}") return ns = "fromchat" desc = readme_summary(readme) or f"FromChat {service}" status, _ = _http_json( "PATCH", f"https://hub.docker.com/v2/repositories/{ns}/{service}/", headers={"Authorization": f"JWT {jwt}"}, body={ "description": desc[:100], "full_description": readme, }, ) if status in (200, 201, 202): ui.substep(f"Docker Hub {ns}/{service} overview ← {repo_root.name}/README") else: create_status, _ = _http_json( "POST", f"https://hub.docker.com/v2/repositories/{ns}/", headers={"Authorization": f"JWT {jwt}"}, body={ "name": service, "namespace": ns, "description": desc[:100], "full_description": readme, "is_private": False, }, ) if create_status in (200, 201, 202) or status in (200, 201, 202): ui.substep(f"Docker Hub {ns}/{service} overview ← {repo_root.name}/README") else: ui.warning( f"Could not update Docker Hub overview for {ns}/{service} " f"(HTTP {status}); image still has OCI source label." ) def bind_github_package(service: str, source_url: str, creds: Creds) -> None: m = re.match(r"https://github\.com/([^/]+)/([^/]+)/?$", source_url.rstrip("/")) if not m: ui.substep(f"GHCR {service}: OCI source label set") return owner, _repo = m.group(1), m.group(2) status, data = _http_json( "GET", f"https://api.github.com/orgs/{owner}/packages/container/{service}", headers={ "Authorization": f"Bearer {creds.token}", "Accept": "application/vnd.github+json", "X-GitHub-Api-Version": "2022-11-28", }, ) if status == 404: status, data = _http_json( "GET", f"https://api.github.com/users/{creds.user}/packages/container/{service}", headers={ "Authorization": f"Bearer {creds.token}", "Accept": "application/vnd.github+json", "X-GitHub-Api-Version": "2022-11-28", }, ) if status == 200 and isinstance(data, dict): linked = ( (data.get("repository") or {}).get("full_name") if isinstance(data.get("repository"), dict) else None ) if linked: ui.substep(f"GHCR {service} linked → {linked}") else: ui.substep(f"GHCR {service}: bound via org.opencontainers.image.source={source_url}") else: ui.substep(f"GHCR {service}: source label set to {source_url}") def bind_repos_after_push( specs: list[ImageSpec], push_to: list[str], creds_map: dict[str, Creds], ) -> None: if not push_to: return ui.step("Binding source repositories") seen_services: set[str] = set() for spec in specs: if spec.service in seen_services: continue seen_services.add(spec.service) source = git_source_url(spec.repo_root) if "dockerhub" in push_to and "dockerhub" in creds_map: bind_dockerhub_repo(spec.service, spec.repo_root, creds_map["dockerhub"]) if "github" in push_to and "github" in creds_map: bind_github_package(spec.service, source, creds_map["github"]) def _parse_args(argv: list[str]) -> argparse.Namespace: ap = argparse.ArgumentParser( description=( "Build FromChat images for linux/amd64 + linux/arm64 and push them to " "GitHub Packages + Gitea (Docker Hub optional). " "Discovers publishable services from compose build blocks. " "Image tags match each repo's git tag on HEAD. " "On a TTY, asks which services to publish (not saved). " f"Registry choices are saved under {SECRETS_DIRNAME}/{PUBLISH_SETTINGS_FILENAME}." ) ) ap.add_argument( "--services", help="Comma-separated compose service names (skip interactive service prompt)", ) ap.add_argument( "--push", nargs="?", const="all", default=None, metavar="REGS", help=( "Registries to push: dockerhub,github,gitea (comma-separated), " "or 'all'. With bare --push, pushes to all. " "Omit to use saved choices / interactive prompt; GitHub + Gitea are always included." ), ) ap.add_argument( "--no-push", action="store_true", help="Build only (multi-arch in buildx); do not push", ) ap.add_argument( "--no-build", action="store_true", help=( "Do not build; retag and push existing local fromchat/: images " "to the selected registries (requires --push destinations or defaults)." ), ) return ap.parse_args(argv) def _resolve_push_to(args: argparse.Namespace, saved: dict[str, object] | None) -> list[str]: if args.no_push: if args.no_build: ui.error("--no-build requires push destinations (cannot combine with --no-push).") raise SystemExit(1) return [] parsed = _parse_push_list(args.push) if parsed is not None: if not parsed: return [] push_to = parsed else: push_to = _saved_registries(saved) if push_to: ui.step("Push destinations (saved + required)") labels = _registry_labels() for name in _ensure_default_push_registries(push_to): if name not in push_to: ui.substep(f"{labels.get(name, name)} — required (added)") else: ui.substep(labels.get(name, name)) elif sys.stdin.isatty() and sys.stdout.isatty(): push_to = _select_registries_interactive(saved) else: push_to = list(DEFAULT_PUSH_REGISTRIES) ui.step("Push destinations (default)") labels = _registry_labels() for name in push_to: ui.substep(labels.get(name, name)) return _ensure_default_push_registries(push_to) def _run(argv: list[str] | None = None) -> None: args = _parse_args(argv if argv is not None else sys.argv[1:]) paths = ProjectPaths.from_deploy_package() saved = load_publish_settings(paths) ui.build_banner() if args.no_build: ui.info("Mode: push local images only (--no-build)") else: ui.info("Platforms: " + PLATFORMS) ui.info("Publishable services are read from compose build: blocks in backend, web, and updater.") ui.info("Tags come from each source repo's git tag on HEAD.") ui.info("Default registries: GitHub Packages + Gitea.") if saved: ui.info(f"Loaded saved registry choices from {SECRETS_DIRNAME}/{PUBLISH_SETTINGS_FILENAME}") all_specs = discover_image_specs(paths) allowed = {s.service for s in all_specs} if args.services: selected_names = parse_services_csv(args.services, allowed) elif sys.stdin.isatty() and sys.stdout.isatty(): selected_names = prompt_services_interactive(all_specs) else: ui.error( "No TTY for service selection. Pass --services=name1,name2 " f"(available: {', '.join(sorted(allowed))})." ) raise SystemExit(1) specs = [s for s in all_specs if s.service in selected_names] push_desired = _resolve_push_to(args, saved) ensure_daemon() if not args.no_build: ensure_buildx(use_compose_build=False) ui.step("Resolving git tags at HEAD") repo_tags = _resolve_tags(specs) creds_map = collect_and_login(push_desired, paths) # Only push where login succeeded. push_to = [name for name in push_desired if name in creds_map] if "dockerhub" in push_to and "dockerhub" in creds_map: if not verify_dockerhub_tags_free(specs, repo_tags, creds_map["dockerhub"]): push_to = [name for name in push_to if name != "dockerhub"] creds_map.pop("dockerhub", None) if not push_to and args.no_build: ui.error("No registries available to push after login/check failures.") raise SystemExit(1) if not push_to and not args.no_build: ui.warning( "No push targets — multi-arch images stay in the buildx builder " "(not loaded into the local Docker engine)." ) pushed_any: set[str] = set() for spec in specs: if not args.no_build and not spec.dockerfile.is_file(): ui.error(f"Dockerfile missing: {spec.dockerfile}") raise SystemExit(1) tag = repo_tags[spec.repo_root] if args.no_build: ok_regs = _push_one_local(spec, tag, push_to=push_to) else: ok_regs = _build_one(spec, tag, push_to=push_to) pushed_any.update(ok_regs) if push_to and not pushed_any: ui.error("Nothing was pushed to any registry.") raise SystemExit(1) bind_repos_after_push(specs, sorted(pushed_any), creds_map) save_publish_settings(paths, registries=push_desired) ui.success("Publish complete" if args.no_build else "Publish build complete") if pushed_any: ui.info("Pushed to: " + ", ".join(sorted(pushed_any))) missed = [name for name in push_desired if name not in pushed_any] if missed and push_desired: ui.warning("Skipped / failed: " + ", ".join(missed)) def main(argv: list[str] | None = None) -> None: try: _run(argv) except KeyboardInterrupt: print(file=sys.stderr) ui.warning("Publish cancelled.") raise SystemExit(130) from None if __name__ == "__main__": main()