txa 1.0.0__tar.gz

txa-1.0.0/PKG-INFO

@@ -0,0 +1,34 @@
+Metadata-Version: 2.4
+Name: txa
+Version: 1.0.0
+Summary: TXA package manager toolchain: txapm (install), txacreate (publish), txaci (16-step validator)
+Author: TXA Software Dev
+License: MIT
+Project-URL: Homepage, https://github.com/TXAVL/txa-repo
+Project-URL: Issues, https://github.com/TXAVL/txa-repo/issues
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: PyYAML>=6.0
+Requires-Dist: requests>=2.31
+Requires-Dist: jsonschema>=4.20
+Requires-Dist: olefile>=0.46
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == "dev"
+Provides-Extra: build
+Requires-Dist: pyinstaller>=6.6; extra == "build"
+
+# txa
+
+Command line tools for the TXA Windows package repository.
+
+```
+pipx install txa
+```
+
+| Command | Purpose |
+|---|---|
+| `txapm` | install, upgrade, uninstall, list, search, export/import TXA packages |
+| `txacreate` | sign in to GitHub and publish installers as pull requests (`new`, `update`, `hash`) |
+| `txaci` | the 16-step manifest validator used by the repository bot |
+
+Source, manifest format and docs: https://github.com/TXAVL/txa-repo

txa-1.0.0/README.md

@@ -0,0 +1,15 @@
+# txa
+
+Command line tools for the TXA Windows package repository.
+
+```
+pipx install txa
+```
+
+| Command | Purpose |
+|---|---|
+| `txapm` | install, upgrade, uninstall, list, search, export/import TXA packages |
+| `txacreate` | sign in to GitHub and publish installers as pull requests (`new`, `update`, `hash`) |
+| `txaci` | the 16-step manifest validator used by the repository bot |
+
+Source, manifest format and docs: https://github.com/TXAVL/txa-repo

txa-1.0.0/pyproject.toml

@@ -0,0 +1,43 @@
+[build-system]
+requires = ["setuptools>=69", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "txa"
+dynamic = ["version"]
+description = "TXA package manager toolchain: txapm (install), txacreate (publish), txaci (16-step validator)"
+readme = "README.md"
+requires-python = ">=3.10"
+license = { text = "MIT" }
+authors = [{ name = "TXA Software Dev" }]
+dependencies = [
+  "PyYAML>=6.0",
+  "requests>=2.31",
+  "jsonschema>=4.20",
+  "olefile>=0.46",
+]
+
+[project.urls]
+Homepage = "https://github.com/TXAVL/txa-repo"
+Issues = "https://github.com/TXAVL/txa-repo/issues"
+
+[project.optional-dependencies]
+dev = ["pytest>=8"]
+build = ["pyinstaller>=6.6"]
+
+[project.scripts]
+txapm = "txa.pm.cli:main"
+txacreate = "txa.create.cli:main"
+txaci = "txa.ci.cli:main"
+
+[tool.setuptools.dynamic]
+version = { attr = "txa.__version__" }
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+txa = ["schemas/*.json"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

txa-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

txa-1.0.0/src/txa/__init__.py

@@ -0,0 +1,3 @@
+"""TXA package manager toolchain."""
+
+__version__ = "1.0.0"

txa-1.0.0/src/txa/ci/__init__.py

@@ -0,0 +1 @@
+"""txaci - the 16-step TXA pull request validator and merge gate."""

txa-1.0.0/src/txa/ci/api.py

@@ -0,0 +1,78 @@
+"""Static JSON API (namespace txa.v1) published to GitHub Pages from txa-repo.
+
+Layout under ``<out>/api/txa/v1/``::
+
+    index.json                 every package, newest version summary
+    packages/<Id>.json         every version of one package, all three cards
+"""
+from __future__ import annotations
+
+import json
+from datetime import datetime, timezone
+from pathlib import Path
+
+from txa.constants import API_NAMESPACE
+from txa.core import semver
+from txa.core.manifest import Bundle, assemble, kind_of, schema_errors
+
+
+def _valid(bundle: Bundle) -> list[str]:
+    problems = [f"{name}: {p}" for name, items in bundle.problems.items() for p in items]
+    for name, card in bundle.cards.items():
+        problems += [f"{name}: {e}" for e in schema_errors(kind_of(name), card)]
+    if not bundle.core or not bundle.build or not bundle.default_about():
+        problems.append("incomplete release (core, build and default about cards are required)")
+    return problems
+
+
+def build_api(repo_root: Path, out: Path) -> dict:
+    packages: dict[str, dict[str, dict]] = {}
+    skipped = []
+    for release in sorted((repo_root / "manifests").glob("*/*/*/*")):
+        if not release.is_dir() or not semver.is_valid(release.name):
+            continue
+        bundle = Bundle.read(release)
+        problems = _valid(bundle)
+        if problems:
+            skipped.append({"path": release.relative_to(repo_root).as_posix(), "problems": problems[:5]})
+            continue
+        packages.setdefault(bundle.package_id, {})[bundle.version] = assemble(bundle)
+
+    api = out / API_NAMESPACE
+    (api / "packages").mkdir(parents=True, exist_ok=True)
+    generated = datetime.now(timezone.utc).isoformat(timespec="seconds")
+    index = []
+    for package_id in sorted(packages, key=str.lower):
+        versions = packages[package_id]
+        ordered = sorted(versions, key=semver.parse, reverse=True)
+        latest = versions[ordered[0]]
+        about = latest["about"].get(latest["core"]["locale"]["default"]) or next(iter(latest["about"].values()))
+        document = {"api": "txa.v1", "id": package_id, "latest": ordered[0], "versions": {v: versions[v] for v in ordered}}
+        (api / "packages" / f"{package_id}.json").write_text(json.dumps(document, ensure_ascii=False, indent=1), "utf-8")
+        index.append({
+            "id": package_id,
+            "alias": latest["core"]["package"].get("alias"),
+            "latest": ordered[0],
+            "versions": ordered,
+            "name": about["name"],
+            "publisher": about["publisher"],
+            "summary": about["summary"],
+            "tags": latest["core"].get("tags", []),
+            "arches": [t["arch"] for t in latest["build"]["targets"]],
+        })
+    manifest = {"api": "txa.v1", "generated": generated, "count": len(index), "packages": index}
+    (api / "index.json").write_text(json.dumps(manifest, ensure_ascii=False, indent=1), "utf-8")
+    (out / ".nojekyll").write_text("", "utf-8")
+    rows = "".join(
+        f"<tr><td><code>{p['id']}</code></td><td>{p['latest']}</td><td>{p['summary']}</td></tr>" for p in index
+    )
+    (out / "index.html").write_text(
+        "<!doctype html><meta charset=utf-8><title>TXA package index</title>"
+        "<style>body{font:15px system-ui;margin:2rem auto;max-width:60rem;padding:0 1rem}"
+        "td,th{padding:.3rem .6rem;border-bottom:1px solid #8884;text-align:left}</style>"
+        f"<h1>TXA package index</h1><p>{len(index)} package(s) · generated {generated} · "
+        f"<a href='{API_NAMESPACE}/index.json'>index.json</a></p>"
+        f"<table><tr><th>Id</th><th>Latest</th><th>Summary</th></tr>{rows}</table>",
+        "utf-8",
+    )
+    return {"packages": len(index), "skipped": skipped, "out": str(api)}

txa-1.0.0/src/txa/ci/cli.py

@@ -0,0 +1,190 @@
+"""txaci - command line entry for the TXA validation pipeline.
+
+CI usage (one GitHub Actions step per command)::
+
+    txaci init --base <sha> --head <sha> --pr <n>
+    txaci step 1 … txaci step 14
+    txaci verdict
+    txaci gate triage --report report.json --head-sha <sha>     # STEP 15
+    txaci gate merge  --report report.json                       # STEP 16
+
+Local usage::
+
+    txaci validate manifests/t/TXAVL/HelloTool/1.4.2 [--offline]
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import sys
+from pathlib import Path
+
+from txa import __version__
+from txa.ci import steps
+from txa.ci.context import Context, init_ci, init_local
+from txa.ci.report import build_report, render_console, render_markdown
+from txa.core import console
+
+LAST_VALIDATION_STEP = 14
+
+
+def _escape(text: str) -> str:
+    return text.replace("%", "%25").replace("\r", "%0D").replace("\n", "%0A")
+
+
+def _emit(number: int, results) -> None:
+    in_actions = os.environ.get("GITHUB_ACTIONS") == "true"
+    for target, outcome in results:
+        print(f"{target['path']} → {outcome.status}")
+        for message in outcome.messages:
+            level, text = message["level"], message["text"]
+            print(f"  [{level}] {text}")
+            if in_actions and level in ("fail", "warn"):
+                kind = "error" if level == "fail" else "warning"
+                print(f"::{kind} title=STEP {number:02d} · {steps.TITLES[number]}::{_escape(target['path'] + ': ' + text)}")
+
+
+def cmd_init(args) -> int:
+    pr = int(args.pr) if args.pr else None
+    ctx = init_ci(Path(args.repo_root), args.base, args.head, pr, Path(args.state))
+    print(f"txaci {__version__}: {len(ctx.targets)} release(s), {len(ctx.outside)} file(s) outside manifests/")
+    for target in ctx.targets:
+        print(f"  {target['mode']:<12} {target['path']}")
+    for path in ctx.outside:
+        print(f"  outside      {path}")
+    return 0
+
+
+def cmd_step(args) -> int:
+    number = int(args.number)
+    if number not in steps.REGISTRY:
+        raise SystemExit(f"txaci: step {number} is not a validation step (1-{LAST_VALIDATION_STEP})")
+    ctx = Context.load(Path(args.state))
+    print(f"STEP {number:02d} · {steps.TITLES[number]}")
+    if not ctx.targets:
+        print("  no manifest releases in this change set - skipped")
+        return 0
+    results = steps.run_step(ctx, number)
+    ctx.save()
+    _emit(number, results)
+    return 1 if any(o.status == "FAIL" for _, o in results) else 0
+
+
+def cmd_verdict(args) -> int:
+    ctx = Context.load(Path(args.state))
+    report = build_report(ctx)
+    path = Path(args.report) if args.report else Path(args.state) / "report.json"
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(report, indent=2), "utf-8")
+    summary = os.environ.get("GITHUB_STEP_SUMMARY")
+    if summary:
+        with open(summary, "a", encoding="utf-8") as fh:
+            fh.write(render_markdown(report))
+    print(render_console(report))
+    print(f"report written to {path}")
+    return 1 if report["verdict"] == "fail" else 0
+
+
+def cmd_validate(args) -> int:
+    ctx = init_local([Path(p) for p in args.paths], offline=args.offline)
+    numbers = sorted(steps.REGISTRY) if not args.only else [int(n) for n in args.only.split(",")]
+    for number in numbers:
+        steps.run_step(ctx, number)
+    report = build_report(ctx)
+    if args.json:
+        Path(args.json).write_text(json.dumps(report, indent=2), "utf-8")
+    print(render_console(report))
+    return 1 if report["verdict"] == "fail" else 0
+
+
+def cmd_gate(args) -> int:
+    from txa.ci import gate
+    from txa.core.github import GitHub
+
+    token = os.environ.get("GH_TOKEN") or os.environ.get("GITHUB_TOKEN")
+    if not token:
+        raise SystemExit("txaci gate: GH_TOKEN is required")
+    repo = args.repo or os.environ.get("GITHUB_REPOSITORY")
+    if not repo:
+        raise SystemExit("txaci gate: --repo or GITHUB_REPOSITORY is required")
+    state = Path(args.state) / "gate.json"
+    report = Path(args.report) if args.report else None
+    gh = GitHub(token)
+    if args.action == "triage":
+        if not args.head_sha:
+            raise SystemExit("txaci gate triage: --head-sha is required")
+        return gate.triage(gh, repo, report, args.head_sha, state, args.run_url)
+    merger = GitHub(os.environ.get("TXA_MERGE_TOKEN") or token)
+    return gate.merge_gate(gh, merger, repo, state, report, args.run_url)
+
+
+def cmd_build_api(args) -> int:
+    from txa.ci.api import build_api
+
+    result = build_api(Path(args.root), Path(args.out))
+    print(f"published {result['packages']} package(s) to {result['out']}")
+    for item in result["skipped"]:
+        print(f"::warning title=Skipped release::{item['path']}: {'; '.join(item['problems'])}")
+    return 0
+
+
+def cmd_schema(args) -> int:
+    from txa.core.manifest import schema
+
+    print(json.dumps(schema(args.kind), indent=2))
+    return 0
+
+
+def main(argv: list[str] | None = None) -> int:
+    console.setup()
+    parser = argparse.ArgumentParser(prog="txaci", description="TXA 16-step manifest validator")
+    parser.add_argument("--version", action="version", version=f"txaci {__version__}")
+    parser.add_argument("--state", default=str(Context.default_state_dir()), help="pipeline state directory")
+    sub = parser.add_subparsers(dest="command", required=True)
+
+    p = sub.add_parser("init", help="collect the change set of a pull request")
+    p.add_argument("--base", required=True)
+    p.add_argument("--head", required=True)
+    p.add_argument("--pr")
+    p.add_argument("--repo-root", default=".")
+    p.set_defaults(func=cmd_init)
+
+    p = sub.add_parser("step", help="run one validation step (1-14)")
+    p.add_argument("number")
+    p.set_defaults(func=cmd_step)
+
+    p = sub.add_parser("verdict", help="write report.json and fail when any step failed")
+    p.add_argument("--report")
+    p.set_defaults(func=cmd_verdict)
+
+    p = sub.add_parser("validate", help="run steps 01-14 against release directories on disk")
+    p.add_argument("paths", nargs="+")
+    p.add_argument("--offline", action="store_true", help="skip network steps 06-09")
+    p.add_argument("--only", help="comma separated step numbers, e.g. 1,2,3")
+    p.add_argument("--json", help="also write the report to this file")
+    p.set_defaults(func=cmd_validate)
+
+    p = sub.add_parser("gate", help="STEP 15 triage / STEP 16 merge gate (trusted workflow only)")
+    p.add_argument("action", choices=["triage", "merge"])
+    p.add_argument("--report")
+    p.add_argument("--head-sha")
+    p.add_argument("--repo")
+    p.add_argument("--run-url")
+    p.set_defaults(func=cmd_gate)
+
+    p = sub.add_parser("build-api", help="generate the static txa.v1 JSON API")
+    p.add_argument("--root", default=".")
+    p.add_argument("--out", default="site")
+    p.set_defaults(func=cmd_build_api)
+
+    p = sub.add_parser("schema", help="print the JSON schema of a card kind")
+    p.add_argument("kind", choices=["core", "build", "about"])
+    p.set_defaults(func=cmd_schema)
+
+    args = parser.parse_args(argv)
+    return args.func(args)
+
+
+if __name__ == "__main__":
+    sys.exit(main())

txa-1.0.0/src/txa/ci/context.py

@@ -0,0 +1,259 @@
+"""Pipeline state shared between steps.
+
+In CI every step runs as its own process (one GitHub Actions step each), so the
+state lives in ``$RUNNER_TEMP/txa-ci/state.json``. Locally everything stays in memory.
+"""
+from __future__ import annotations
+
+import copy
+import json
+import os
+import subprocess
+from datetime import datetime, timezone
+from pathlib import Path, PurePosixPath
+
+import yaml
+
+from txa import __version__
+from txa.core import semver
+from txa.core.manifest import Bundle, find_repo_root
+
+POLICY_FILE = "policy.txa.yaml"
+
+DEFAULT_POLICY: dict = {
+    "namespaces": ["TXAVL"],
+    "limits": {
+        "max_payload_mb": 2048,
+        "max_redirects": 8,
+        "http_timeout_s": 30,
+        "max_line_length": 400,
+    },
+    "network": {
+        "min_regions_ok": 3,
+        # EDNS Client Subnet hints: the resolver answers as if the client sat in that network.
+        "regions": {
+            "vn-hanoi": "113.160.0.0/24",
+            "sg-singapore": "203.116.0.0/24",
+            "jp-tokyo": "126.0.0.0/24",
+            "au-sydney": "1.120.0.0/24",
+            "de-frankfurt": "79.192.0.0/24",
+            "us-east": "73.0.0.0/24",
+        },
+    },
+    "signature": {"require": False},
+    "os": {"floor": "10.0.17763"},
+}
+
+
+def _merge(base: dict, override: dict) -> dict:
+    out = copy.deepcopy(base)
+    for key, value in (override or {}).items():
+        if isinstance(value, dict) and isinstance(out.get(key), dict):
+            out[key] = _merge(out[key], value)
+        else:
+            out[key] = value
+    return out
+
+
+def parse_policy(text: str | None) -> dict:
+    if not text:
+        return copy.deepcopy(DEFAULT_POLICY)
+    data = yaml.safe_load(text) or {}
+    data.pop("txa", None)
+    data.pop("kind", None)
+    return _merge(DEFAULT_POLICY, data)
+
+
+# --------------------------------------------------------------------------- git
+
+
+def git(repo: Path, *args: str, check: bool = True) -> str:
+    proc = subprocess.run(["git", *args], cwd=repo, capture_output=True, text=True, encoding="utf-8")
+    if check and proc.returncode != 0:
+        raise RuntimeError(f"git {' '.join(args)} failed: {proc.stderr.strip()}")
+    return proc.stdout if proc.returncode == 0 else ""
+
+
+def changed_files(repo: Path, base: str, head: str) -> list[tuple[str, str]]:
+    out = git(repo, "diff", "--name-status", "--no-renames", "-z", f"{base}...{head}")
+    fields = [f for f in out.split("\0") if f]
+    return [(fields[i][0], fields[i + 1]) for i in range(0, len(fields) - 1, 2)]
+
+
+def tree_dirs(repo: Path, rev: str, path: str) -> list[str]:
+    out = git(repo, "ls-tree", "-d", "--name-only", f"{rev}:{path}", check=False)
+    return [line for line in out.splitlines() if line]
+
+
+def show(repo: Path, rev: str, path: str) -> str | None:
+    proc = subprocess.run(["git", "show", f"{rev}:{path}"], cwd=repo, capture_output=True, text=True, encoding="utf-8")
+    return proc.stdout if proc.returncode == 0 else None
+
+
+# --------------------------------------------------------------------------- context
+
+
+class Context:
+    def __init__(self, data: dict, state_dir: Path | None = None):
+        self.data = data
+        self.state_dir = state_dir
+        self.payloads: dict[str, dict[str, Path]] = {}
+        self._bundles: dict[str, Bundle] = {}
+
+    # ---- persistence
+    @staticmethod
+    def default_state_dir() -> Path:
+        base = os.environ.get("TXA_STATE_DIR") or (
+            str(Path(os.environ["RUNNER_TEMP"]) / "txa-ci") if os.environ.get("RUNNER_TEMP") else ".txa-ci"
+        )
+        return Path(base)
+
+    @classmethod
+    def load(cls, state_dir: Path) -> "Context":
+        path = state_dir / "state.json"
+        if not path.exists():
+            raise SystemExit(f"txaci: no pipeline state at {path} - run `txaci init` first")
+        return cls(json.loads(path.read_text("utf-8")), state_dir)
+
+    def save(self) -> None:
+        if self.state_dir is None:
+            return
+        self.state_dir.mkdir(parents=True, exist_ok=True)
+        (self.state_dir / "state.json").write_text(json.dumps(self.data, indent=2), "utf-8")
+
+    # ---- accessors
+    @property
+    def mode(self) -> str:
+        return self.data["mode"]
+
+    @property
+    def repo_root(self) -> Path:
+        return Path(self.data["repo_root"])
+
+    @property
+    def policy(self) -> dict:
+        return self.data["policy"]
+
+    @property
+    def offline(self) -> bool:
+        return bool(self.data.get("offline"))
+
+    @property
+    def targets(self) -> list[dict]:
+        return self.data["targets"]
+
+    @property
+    def outside(self) -> list[str]:
+        return self.data.get("outside", [])
+
+    def bundle(self, target: dict) -> Bundle:
+        key = target["path"]
+        if key not in self._bundles:
+            self._bundles[key] = Bundle.read(self.repo_root / key)
+        return self._bundles[key]
+
+    def artifact(self, target: dict, arch: str) -> dict:
+        return self.data.setdefault("artifacts", {}).setdefault(f"{target['path']}#{arch}", {})
+
+    def payload_dir(self, target: dict, arch: str) -> Path:
+        import hashlib
+
+        tag = hashlib.sha1(f"{target['path']}#{arch}".encode()).hexdigest()[:12]
+        root = self.state_dir or Path(".txa-ci")
+        return root / "payloads" / tag
+
+    def record(self, step: int, target: dict, status: str, messages: list[dict]) -> None:
+        results = [r for r in self.data.setdefault("results", []) if not (r["step"] == step and r["target"] == target["path"])]
+        results.append({"step": step, "target": target["path"], "status": status, "messages": messages})
+        self.data["results"] = sorted(results, key=lambda r: (r["target"], r["step"]))
+
+    def results(self) -> list[dict]:
+        return self.data.get("results", [])
+
+
+def _base_state(mode: str, repo_root: Path, policy: dict) -> dict:
+    return {
+        "tool": f"txaci {__version__}",
+        "mode": mode,
+        "repo_root": str(repo_root.resolve()),
+        "policy": policy,
+        "created": datetime.now(timezone.utc).isoformat(timespec="seconds"),
+        "targets": [],
+        "outside": [],
+        "results": [],
+        "artifacts": {},
+    }
+
+
+def init_ci(repo_root: Path, base: str, head: str, pr: int | None, state_dir: Path) -> Context:
+    """Build the change set of a pull request. The policy always comes from the base commit."""
+    data = _base_state("ci", repo_root, parse_policy(show(repo_root, base, POLICY_FILE)))
+    data.update({"base": base, "head": head, "pr": pr})
+    changes = changed_files(repo_root, base, head)
+    data["changes"] = [{"status": s, "path": p} for s, p in changes]
+    releases: dict[str, dict] = {}
+    for status, path in changes:
+        parts = PurePosixPath(path).parts
+        if not parts or parts[0] != "manifests":
+            data["outside"].append(path)
+            continue
+        release = "/".join(parts[:5]) if len(parts) >= 6 else str(PurePosixPath(path).parent)
+        entry = releases.setdefault(release, {"path": release, "changed": [], "deleted": []})
+        entry["changed"].append(path)
+        if status == "D":
+            entry["deleted"].append(path)
+    for release, entry in sorted(releases.items()):
+        package = str(PurePosixPath(release).parent)
+        version = PurePosixPath(release).name
+        base_versions = tree_dirs(repo_root, base, package)
+        existed = version in base_versions
+        still_there = (repo_root / release).is_dir() and any((repo_root / release).iterdir())
+        if not still_there:
+            mode = "removal"
+        elif existed:
+            mode = "update"
+        elif base_versions:
+            mode = "new-version"
+        else:
+            mode = "new-app"
+        data["targets"].append({
+            "path": release,
+            "mode": mode,
+            "existing_versions": [v for v in base_versions if v != version],
+            "changed": entry["changed"],
+        })
+    ctx = Context(data, state_dir)
+    ctx.save()
+    return ctx
+
+
+def init_local(release_dirs: list[Path], offline: bool = False,
+               payloads: dict[str, dict[str, Path]] | None = None) -> Context:
+    """Validate release directories on disk (used by `txaci validate` and txacreate)."""
+    first = Path(release_dirs[0]).resolve()
+    repo_root = find_repo_root(first) or first.parent
+    policy_file = repo_root / POLICY_FILE
+    policy = parse_policy(policy_file.read_text("utf-8") if policy_file.exists() else None)
+    data = _base_state("local", repo_root, policy)
+    data["offline"] = offline
+    ctx = Context(data)
+    for directory in release_dirs:
+        directory = Path(directory).resolve()
+        try:
+            rel = directory.relative_to(repo_root).as_posix()
+        except ValueError:
+            rel = directory.as_posix()
+        siblings = [p.name for p in directory.parent.iterdir() if p.is_dir() and p.name != directory.name] \
+            if directory.parent.is_dir() else []
+        siblings = [s for s in siblings if semver.is_valid(s)]
+        data["targets"].append({
+            "path": rel,
+            "mode": "new-version" if siblings else "new-app",
+            "existing_versions": siblings,
+            "changed": [],
+        })
+        if payloads and rel in payloads:
+            ctx.payloads[rel] = payloads[rel]
+        elif payloads and str(directory) in payloads:
+            ctx.payloads[rel] = payloads[str(directory)]
+    return ctx