From c38baa2c2d6c6c387fa3e93768f65eca7b47c836 Mon Sep 17 00:00:00 2001 From: blockmandev <194144408+blockmandev@users.noreply.github.com> Date: Sat, 24 Oct 2026 10:16:09 -0600 Subject: [PATCH 1/2] feat: winget, Scoop and Homebrew manifests made from each release, and installed with (refs #56) Package managers need a manifest per release naming each archive and its sha256. Written by hand they drift from what was published, so they are made from the release's own SHA256SUMS: - scripts/package_manifests.py (standard library only) renders the winget version/installer/locale files (a zip of two portable commands), a Scoop manifest with checkver/autoupdate, and a Homebrew formula for macOS and Linux on Intel and ARM whose test checks both programs' versions. Pre-release tags are refused; a missing archive or a malformed sum line is an error, not skipped. - .github/workflows/package-check.yml makes them for a tag and installs with each, as a user would: winget (validate, then install the local manifest) and Scoop on Windows, Homebrew from a local tap on macOS and Linux; both programs must report the tag's version. The manifests are uploaded as an artifact, ready to submit. - release.yml runs it after the install check, for release tags only. A pull request that changes the generator runs it against the latest release. Submitting (a winget-pkgs pull request, a Scoop bucket, a Homebrew tap) needs the owner's accounts and is not done here. Tested: 10 unit tests (scripts/tests); for v0.1.0 the generated winget manifest passes `winget validate` (winget 1.29) and the downloaded archives' hashes match the release's SHA256SUMS. --- .github/workflows/package-check.yml | 176 ++++++++++++++++++ .github/workflows/release.yml | 10 + scripts/package_manifests.py | 233 ++++++++++++++++++++++++ scripts/tests/test_package_manifests.py | 115 ++++++++++++ 4 files changed, 534 insertions(+) create mode 100644 .github/workflows/package-check.yml create mode 100644 scripts/package_manifests.py create mode 100644 scripts/tests/test_package_manifests.py diff --git a/.github/workflows/package-check.yml b/.github/workflows/package-check.yml new file mode 100644 index 0000000..e60f4f1 --- /dev/null +++ b/.github/workflows/package-check.yml @@ -0,0 +1,176 @@ +# The package-manager manifests for a published release, made from its own +# SHA256SUMS (scripts/package_manifests.py) and then installed with, the way +# a user would install with each: winget and Scoop on Windows, Homebrew on +# macOS and Linux. Each install must report the tag's version from both +# programs. The manifests are uploaded as the `package-manifests` artifact, +# ready to submit (winget-pkgs pull request, a Scoop bucket, a Homebrew tap). +# +# release.yml calls this after the install check, for release tags only +# (package managers do not offer pre-releases). A pull request that changes +# the generator or this workflow runs it against the latest release. Run it +# by hand with: +# gh workflow run package-check.yml -f tag=v0.1.0 +name: package check + +on: + workflow_call: + inputs: + tag: + required: true + type: string + workflow_dispatch: + inputs: + tag: + description: The release tag, such as v0.1.0. + required: true + type: string + pull_request: + paths: + - scripts/package_manifests.py + - scripts/tests/** + - .github/workflows/package-check.yml + +permissions: + contents: read + +jobs: + manifests: + runs-on: ubuntu-latest + outputs: + tag: ${{ steps.tag.outputs.tag }} + env: + GH_TOKEN: ${{ github.token }} + steps: + - uses: actions/checkout@v4 + - name: Which release + id: tag + env: + GIVEN: ${{ inputs.tag }} + run: | + set -euo pipefail + tag="${GIVEN:-$(gh release view --repo "$GITHUB_REPOSITORY" --json tagName --jq .tagName)}" + echo "checking $tag" + echo "tag=$tag" >> "$GITHUB_OUTPUT" + echo "TAG=$tag" >> "$GITHUB_ENV" + - name: Test the generator + run: python3 -m unittest discover -s scripts/tests + - name: The release's checksums + run: gh release download "$TAG" --repo "$GITHUB_REPOSITORY" --pattern SHA256SUMS --dir "$RUNNER_TEMP" + - name: Make the manifests + run: python3 scripts/package_manifests.py --tag "$TAG" --sums "$RUNNER_TEMP/SHA256SUMS" --out manifests + - uses: actions/upload-artifact@v4 + with: + name: package-manifests + path: manifests + if-no-files-found: error + + winget: + needs: manifests + runs-on: windows-2025 + env: + TAG: ${{ needs.manifests.outputs.tag }} + steps: + - uses: actions/download-artifact@v4 + with: + name: package-manifests + path: manifests + - name: Validate and install with winget + shell: pwsh + run: | + if (-not (Get-Command winget -ErrorAction SilentlyContinue)) { + Write-Output "::error::winget is not on this runner; the manifest was not installed" + exit 1 + } + winget --version + winget validate --manifest manifests/winget + if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE } + # A local manifest installs only once this is on (the runner is admin). + winget settings --enable LocalManifestFiles + winget install --manifest manifests/winget --accept-package-agreements --accept-source-agreements --disable-interactivity + if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE } + - name: The installed programs report the tag's version + shell: pwsh + run: | + # winget puts portable commands in this folder and adds it to the + # user PATH, which this already-running shell has not read. + $links = Join-Path $env:LOCALAPPDATA 'Microsoft\WinGet\Links' + $want = $env:TAG.TrimStart('v') + foreach ($program in 'incode', 'sbx') { + $got = & (Join-Path $links "$program.exe") --version + Write-Output "$program --version: $got" + if ($got -ne "$program $want") { + Write-Output "::error::$program reports '$got', expected '$program $want'" + exit 1 + } + } + + scoop: + needs: manifests + runs-on: windows-latest + env: + TAG: ${{ needs.manifests.outputs.tag }} + steps: + - uses: actions/download-artifact@v4 + with: + name: package-manifests + path: manifests + - name: Install Scoop, then incode from the manifest + shell: pwsh + run: | + Invoke-RestMethod https://get.scoop.sh -OutFile "$env:RUNNER_TEMP\install-scoop.ps1" + & "$env:RUNNER_TEMP\install-scoop.ps1" -RunAsAdmin + $shims = Join-Path $env:USERPROFILE 'scoop\shims' + & (Join-Path $shims 'scoop.cmd') install manifests/scoop/incode.json + if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE } + Add-Content -Path $env:GITHUB_PATH -Value $shims + - name: The installed programs report the tag's version + shell: pwsh + run: | + $want = $env:TAG.TrimStart('v') + foreach ($program in 'incode', 'sbx') { + $got = & $program --version + Write-Output "$program --version: $got" + if ($got -ne "$program $want") { + Write-Output "::error::$program reports '$got', expected '$program $want'" + exit 1 + } + } + + homebrew: + needs: manifests + name: homebrew (${{ matrix.os }}) + strategy: + fail-fast: false + matrix: + os: [macos-latest, ubuntu-latest] + runs-on: ${{ matrix.os }} + env: + TAG: ${{ needs.manifests.outputs.tag }} + HOMEBREW_NO_AUTO_UPDATE: "1" + steps: + - uses: actions/download-artifact@v4 + with: + name: package-manifests + path: manifests + - name: Put Homebrew on the PATH (Linux) + if: runner.os == 'Linux' + run: echo "/home/linuxbrew/.linuxbrew/bin" >> "$GITHUB_PATH" + - name: Install from a local tap, then run the formula's own test + run: | + set -euo pipefail + brew tap-new --no-git incode-check/local + cp manifests/homebrew/incode.rb "$(brew --repository)/Library/Taps/incode-check/homebrew-local/Formula/" + brew install incode-check/local/incode + brew test incode-check/local/incode + - name: The installed programs report the tag's version + run: | + set -euo pipefail + want="${TAG#v}" + for program in incode sbx; do + got="$("$(brew --prefix)/bin/$program" --version)" + echo "$program --version: $got" + if [ "$got" != "$program $want" ]; then + echo "::error::$program reports '$got', expected '$program $want'" + exit 1 + fi + done diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml index 386da3c..816cad6 100644 --- a/.github/workflows/release.yml +++ b/.github/workflows/release.yml @@ -151,3 +151,13 @@ jobs: uses: ./.github/workflows/install-check.yml with: tag: ${{ github.ref_name }} + + # The winget, Scoop and Homebrew manifests for this release, made from its + # SHA256SUMS and installed with on each platform; uploaded ready to submit. + # Release tags only: package managers do not offer pre-releases. + package-check: + needs: install-check + if: ${{ !contains(github.ref_name, '-') }} + uses: ./.github/workflows/package-check.yml + with: + tag: ${{ github.ref_name }} diff --git a/scripts/package_manifests.py b/scripts/package_manifests.py new file mode 100644 index 0000000..60ba587 --- /dev/null +++ b/scripts/package_manifests.py @@ -0,0 +1,233 @@ +#!/usr/bin/env python3 +"""Package-manager manifests for one incode release: winget, Scoop and Homebrew. + +Each is rendered from the release's own SHA256SUMS (the `sha256sum` lines the +release workflow publishes beside the archives), so a manifest can only name +an archive and hash that release actually has. + + python3 scripts/package_manifests.py --tag v0.1.0 --sums SHA256SUMS --out DIR + +writes + DIR/winget/IncordAI.Incode.yaml (version) + DIR/winget/IncordAI.Incode.installer.yaml + DIR/winget/IncordAI.Incode.locale.en-US.yaml + DIR/scoop/incode.json + DIR/homebrew/incode.rb + +Submitting them is the owner's: winget-pkgs takes a pull request under +manifests/i/IncordAI/Incode//, Scoop a bucket, Homebrew a tap. + +Wired to: .github/workflows/package-check.yml, which runs this for a tag and +installs with what it wrote (Scoop on Windows, Homebrew on macOS and Linux, +winget on Windows); release.yml calls that after publishing. Tested by +scripts/tests/test_package_manifests.py. The archive names are the ones +release.yml builds (its `build` matrix) and scripts/install.sh and +scripts/install.ps1 download. + +Standard library only, so it runs wherever Python 3 does. +""" + +from __future__ import annotations + +import argparse +import json +import re +import sys +from pathlib import Path + +REPO = "incordai/Incode" +HOMEPAGE = f"https://github.com/{REPO}" +WINGET_ID = "IncordAI.Incode" +PUBLISHER = "Incord AI" +LICENSE = "Apache-2.0" +# Under 80 characters and not starting with an article or the name: what +# Homebrew's audit asks of `desc`. Used by all three. +SUMMARY = "Coding harness that runs your agent CLI under its own tools, checks and sandbox" +WINGET_SCHEMA = "1.10.0" + +# The archive each platform gets, as release.yml names them. +WINDOWS_X64 = "incode-x86_64-pc-windows-msvc.zip" +MACOS_ARM = "incode-aarch64-apple-darwin.tar.gz" +MACOS_INTEL = "incode-x86_64-apple-darwin.tar.gz" +LINUX_ARM = "incode-aarch64-unknown-linux-gnu.tar.gz" +LINUX_INTEL = "incode-x86_64-unknown-linux-gnu.tar.gz" +ARCHIVES = (WINDOWS_X64, MACOS_ARM, MACOS_INTEL, LINUX_ARM, LINUX_INTEL) + +TAG = re.compile(r"^v(\d+\.\d+\.\d+)$") +SUM_LINE = re.compile(r"^([0-9a-f]{64}) [ *]?(\S+)$") + + +class ManifestError(Exception): + """A tag or SHA256SUMS these manifests cannot be made from.""" + + +def version_of(tag: str) -> str: + """`v1.2.3` -> `1.2.3`. A pre-release tag (`v1.2.3-rc.1`) is refused: + package managers offer releases, and GitHub's `releases/latest` skips + pre-releases for the same reason.""" + match = TAG.match(tag) + if not match: + raise ManifestError(f"'{tag}' is not a release tag like v1.2.3") + return match.group(1) + + +def parse_sums(text: str) -> dict[str, str]: + """Archive name -> lower-case sha256, from `sha256sum` output. Every + archive the manifests name must be there, and a line that is not a sum + is an error rather than skipped.""" + sums: dict[str, str] = {} + for number, raw in enumerate(text.splitlines(), start=1): + line = raw.strip() + if not line: + continue + match = SUM_LINE.match(line) + if not match: + raise ManifestError(f"SHA256SUMS line {number} is not ` `: {raw!r}") + sums[match.group(2)] = match.group(1) + missing = [name for name in ARCHIVES if name not in sums] + if missing: + raise ManifestError(f"SHA256SUMS has no line for {', '.join(missing)}") + return sums + + +def url(tag: str, archive: str) -> str: + return f"{HOMEPAGE}/releases/download/{tag}/{archive}" + + +def winget(tag: str, version: str, sums: dict[str, str]) -> dict[str, str]: + """The three winget files: a zip holding two portable commands.""" + head = f"PackageIdentifier: {WINGET_ID}\nPackageVersion: {version}\n" + + def tail(kind: str) -> str: + return f"ManifestType: {kind}\nManifestVersion: {WINGET_SCHEMA}\n" + + def schema(kind: str) -> str: + return ( + "# yaml-language-server: $schema=https://aka.ms/winget-manifest." + f"{kind}.{WINGET_SCHEMA}.schema.json\n" + ) + + return { + f"{WINGET_ID}.yaml": schema("version") + + head + + "DefaultLocale: en-US\n" + + tail("version"), + f"{WINGET_ID}.installer.yaml": schema("installer") + + head + + "InstallerType: zip\n" + + "NestedInstallerType: portable\n" + + "NestedInstallerFiles:\n" + + "- RelativeFilePath: incode.exe\n PortableCommandAlias: incode\n" + + "- RelativeFilePath: sbx.exe\n PortableCommandAlias: sbx\n" + + "Installers:\n" + + "- Architecture: x64\n" + + f" InstallerUrl: {url(tag, WINDOWS_X64)}\n" + + f" InstallerSha256: {sums[WINDOWS_X64].upper()}\n" + + tail("installer"), + f"{WINGET_ID}.locale.en-US.yaml": schema("defaultLocale") + + head + + "PackageLocale: en-US\n" + + f"Publisher: {PUBLISHER}\n" + + "PublisherUrl: https://github.com/incordai\n" + + "PackageName: incode\n" + + f"PackageUrl: {HOMEPAGE}\n" + + f"License: {LICENSE}\n" + + f"LicenseUrl: {HOMEPAGE}/blob/{tag}/LICENSE\n" + + f"ShortDescription: {SUMMARY}\n" + + f"ReleaseNotesUrl: {HOMEPAGE}/releases/tag/{tag}\n" + + tail("defaultLocale"), + } + + +def scoop(tag: str, version: str, sums: dict[str, str]) -> str: + """A Scoop manifest, with `checkver`/`autoupdate` so a bucket can follow + new releases from the same SHA256SUMS.""" + manifest = { + "version": version, + "description": SUMMARY, + "homepage": HOMEPAGE, + "license": LICENSE, + "architecture": { + "64bit": {"url": url(tag, WINDOWS_X64), "hash": sums[WINDOWS_X64]}, + }, + "bin": ["incode.exe", "sbx.exe"], + "checkver": {"github": HOMEPAGE}, + "autoupdate": { + "architecture": { + "64bit": {"url": f"{HOMEPAGE}/releases/download/v$version/{WINDOWS_X64}"}, + }, + "hash": {"url": "$baseurl/SHA256SUMS"}, + }, + } + return json.dumps(manifest, indent=4) + "\n" + + +def homebrew(tag: str, version: str, sums: dict[str, str]) -> str: + """A Homebrew formula for macOS and Linux, Intel and ARM: the prebuilt + archives, installed as they are, and a test that each program reports + the formula's version.""" + + def block(archive: str) -> str: + return f' url "{url(tag, archive)}"\n sha256 "{sums[archive]}"\n' + + return ( + "class Incode < Formula\n" + f' desc "{SUMMARY}"\n' + f' homepage "{HOMEPAGE}"\n' + f' version "{version}"\n' + f' license "{LICENSE}"\n' + "\n" + " on_macos do\n" + " on_arm do\n" + block(MACOS_ARM) + " end\n" + " on_intel do\n" + block(MACOS_INTEL) + " end\n" + " end\n" + "\n" + " on_linux do\n" + " on_arm do\n" + block(LINUX_ARM) + " end\n" + " on_intel do\n" + block(LINUX_INTEL) + " end\n" + " end\n" + "\n" + " def install\n" + ' bin.install "incode", "sbx"\n' + " end\n" + "\n" + " test do\n" + ' assert_equal "incode #{version}", shell_output("#{bin}/incode --version").strip\n' + ' assert_equal "sbx #{version}", shell_output("#{bin}/sbx --version").strip\n' + " end\n" + "end\n" + ) + + +def render(tag: str, sums_text: str) -> dict[str, str]: + """Every file, by its path under the output folder.""" + version = version_of(tag) + sums = parse_sums(sums_text) + files = {f"winget/{name}": text for name, text in winget(tag, version, sums).items()} + files["scoop/incode.json"] = scoop(tag, version, sums) + files["homebrew/incode.rb"] = homebrew(tag, version, sums) + return files + + +def main(argv: list[str]) -> int: + parser = argparse.ArgumentParser(description=__doc__.splitlines()[0]) + parser.add_argument("--tag", required=True, help="the release tag, such as v0.1.0") + parser.add_argument("--sums", required=True, type=Path, help="that release's SHA256SUMS") + parser.add_argument("--out", required=True, type=Path, help="folder to write into") + args = parser.parse_args(argv) + try: + files = render(args.tag, args.sums.read_text(encoding="utf-8")) + except (ManifestError, OSError) as why: + print(f"package_manifests: {why}", file=sys.stderr) + return 1 + for relative, text in files.items(): + path = args.out / relative + path.parent.mkdir(parents=True, exist_ok=True) + # LF on every platform: these files are submitted as they are. + path.write_bytes(text.encode("utf-8")) + print(path) + return 0 + + +if __name__ == "__main__": + sys.exit(main(sys.argv[1:])) diff --git a/scripts/tests/test_package_manifests.py b/scripts/tests/test_package_manifests.py new file mode 100644 index 0000000..ff6d647 --- /dev/null +++ b/scripts/tests/test_package_manifests.py @@ -0,0 +1,115 @@ +"""Tests for scripts/package_manifests.py. + + python -m unittest discover -s scripts/tests + +The real check is .github/workflows/package-check.yml, which installs with +what the script writes; these pin what it writes and what it refuses. +""" + +from __future__ import annotations + +import json +import sys +import tempfile +import unittest +from pathlib import Path + +sys.path.insert(0, str(Path(__file__).resolve().parent.parent)) + +import package_manifests as pm # noqa: E402 (the path is set just above) + +# One distinct hash per archive, so a manifest that names the wrong one fails. +HASHES = {name: f"{index:x}" * 64 for index, name in enumerate(pm.ARCHIVES, start=1)} +HASHES = {name: digest[:64] for name, digest in HASHES.items()} +SUMS = "".join(f"{digest} {name}\n" for name, digest in HASHES.items()) + + +class Render(unittest.TestCase): + def setUp(self) -> None: + self.files = pm.render("v1.2.3", SUMS) + + def test_every_manifest_is_written(self) -> None: + self.assertEqual( + sorted(self.files), + [ + "homebrew/incode.rb", + "scoop/incode.json", + "winget/IncordAI.Incode.installer.yaml", + "winget/IncordAI.Incode.locale.en-US.yaml", + "winget/IncordAI.Incode.yaml", + ], + ) + + def test_winget_installs_both_programs_from_the_windows_zip(self) -> None: + installer = self.files["winget/IncordAI.Incode.installer.yaml"] + self.assertIn( + "InstallerUrl: https://github.com/incordai/Incode/releases/download/v1.2.3/" + "incode-x86_64-pc-windows-msvc.zip\n", + installer, + ) + self.assertIn(f"InstallerSha256: {HASHES[pm.WINDOWS_X64].upper()}\n", installer) + self.assertIn("PortableCommandAlias: incode\n", installer) + self.assertIn("PortableCommandAlias: sbx\n", installer) + for name in self.files: + if name.startswith("winget/"): + self.assertIn("PackageVersion: 1.2.3\n", self.files[name], name) + + def test_scoop_names_the_zip_its_hash_and_both_programs(self) -> None: + manifest = json.loads(self.files["scoop/incode.json"]) + self.assertEqual(manifest["version"], "1.2.3") + self.assertEqual(manifest["architecture"]["64bit"]["hash"], HASHES[pm.WINDOWS_X64]) + self.assertTrue(manifest["architecture"]["64bit"]["url"].endswith(pm.WINDOWS_X64)) + self.assertEqual(manifest["bin"], ["incode.exe", "sbx.exe"]) + + def test_homebrew_gives_each_platform_its_own_archive_and_hash(self) -> None: + formula = self.files["homebrew/incode.rb"] + for archive in (pm.MACOS_ARM, pm.MACOS_INTEL, pm.LINUX_ARM, pm.LINUX_INTEL): + block = f'url "{pm.url("v1.2.3", archive)}"\n sha256 "{HASHES[archive]}"\n' + self.assertIn(block, formula, archive) + self.assertNotIn(pm.WINDOWS_X64, formula) + self.assertIn('bin.install "incode", "sbx"', formula) + + def test_the_summary_fits_homebrews_rules(self) -> None: + self.assertLess(len(pm.SUMMARY), 80) + self.assertNotIn("incode", pm.SUMMARY.lower()) + self.assertFalse(pm.SUMMARY.lower().startswith(("a ", "an ", "the "))) + + def test_files_are_written_with_lf_line_ends(self) -> None: + with tempfile.TemporaryDirectory() as scratch: + sums = Path(scratch) / "SHA256SUMS" + sums.write_text(SUMS, encoding="utf-8") + out = Path(scratch) / "out" + argv = ["--tag", "v1.2.3", "--sums", str(sums), "--out", str(out)] + self.assertEqual(pm.main(argv), 0) + written = (out / "homebrew" / "incode.rb").read_bytes() + self.assertNotIn(b"\r\n", written) + self.assertEqual(written.decode("utf-8"), self.files["homebrew/incode.rb"]) + + +class Refusals(unittest.TestCase): + def test_a_pre_release_or_odd_tag_is_refused(self) -> None: + for tag in ("v1.2.3-rc.1", "1.2.3", "v1.2", "latest"): + with self.assertRaises(pm.ManifestError, msg=tag): + pm.render(tag, SUMS) + + def test_a_missing_archive_is_named(self) -> None: + partial = "".join(line + "\n" for line in SUMS.splitlines() if pm.LINUX_ARM not in line) + with self.assertRaisesRegex(pm.ManifestError, pm.LINUX_ARM): + pm.render("v1.2.3", partial) + + def test_a_line_that_is_not_a_sum_is_an_error(self) -> None: + with self.assertRaisesRegex(pm.ManifestError, "line 6"): + pm.render("v1.2.3", SUMS + "not a checksum line\n") + + def test_main_reports_a_refusal_and_exits_non_zero(self) -> None: + with tempfile.TemporaryDirectory() as scratch: + sums = Path(scratch) / "SHA256SUMS" + sums.write_text(SUMS, encoding="utf-8") + out = Path(scratch) / "out" + argv = ["--tag", "v1.2.3-rc.1", "--sums", str(sums), "--out", str(out)] + self.assertEqual(pm.main(argv), 1) + self.assertFalse(out.exists()) + + +if __name__ == "__main__": + unittest.main() From 89e916fa4812dc31456dae51b66a63654aad6851 Mon Sep 17 00:00:00 2001 From: blockmandev <194144408+blockmandev@users.noreply.github.com> Date: Sat, 24 Oct 2026 10:24:23 -0600 Subject: [PATCH 2/2] package check: hand Scoop the manifest by absolute path (refs #56) Root cause: given a relative manifests/scoop/incode.json, Scoop parses it as /, reports the manifest not found and exits 0; the version check caught it. An absolute path is read as a manifest file. --- .github/workflows/package-check.yml | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/.github/workflows/package-check.yml b/.github/workflows/package-check.yml index e60f4f1..b216e9e 100644 --- a/.github/workflows/package-check.yml +++ b/.github/workflows/package-check.yml @@ -120,7 +120,12 @@ jobs: Invoke-RestMethod https://get.scoop.sh -OutFile "$env:RUNNER_TEMP\install-scoop.ps1" & "$env:RUNNER_TEMP\install-scoop.ps1" -RunAsAdmin $shims = Join-Path $env:USERPROFILE 'scoop\shims' - & (Join-Path $shims 'scoop.cmd') install manifests/scoop/incode.json + # An absolute path: a relative `manifests/scoop/incode.json` reads + # to Scoop as `/`, which it reports as not found and + # still exits 0 (measured), so the version check below is what + # proves the install. + $manifest = (Resolve-Path manifests/scoop/incode.json).Path + & (Join-Path $shims 'scoop.cmd') install $manifest if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE } Add-Content -Path $env:GITHUB_PATH -Value $shims - name: The installed programs report the tag's version