401 lines
21 KiB
YAML
401 lines
21 KiB
YAML
# Public firmware builds of this fork -- runs only in the published repo
|
||
# (git.rfa.cz tth-pub/meshcore-tth), skipped anywhere else.
|
||
#
|
||
# Generic envs only: upstream's placeholder BLE PIN (123456) and admin
|
||
# password ("password") -- change both on the node after flashing. Nothing
|
||
# here carries a site's identity or real secrets.
|
||
#
|
||
# Defaults follow the Czech mesh (meshcore.cz wiki: nastaveni_site_meshcore_cz,
|
||
# instalace_repeateru, regiony), PUB_FLAGS below. They apply to a node with
|
||
# no saved settings (fresh, or after an erase); a reflash keeps what is set.
|
||
#
|
||
# Runs on every push to main -- the export pushes there only after an
|
||
# upstream merge (private repo, tth-upstream-sync) -- and by hand.
|
||
# Release tag v1.18.0+tth.<commit date>[.n] (the n-th release of that day),
|
||
# titled "v1.18.0+tth · 12. 11. 2026"; assets carry the tag in their names, the
|
||
# body the version the node reports (`ver`: v1.18.0-tth<sha>). Until 12. 11.
|
||
# 2026 the tags were tth-<sha8>; pruning and the changelog know both;
|
||
# the newest KEEP releases stay, older ones are deleted. The body is a
|
||
# changelog since the previous release: our own commits, then the upstream
|
||
# PRs the upstream merges brought in.
|
||
# nRF52: .uf2 (drag onto the bootloader drive) and .zip (DFU over BLE or
|
||
# serial); ESP32: -merged.bin (fresh install at 0x0) and .bin (update).
|
||
#
|
||
# EXPERIMENTAL -ota images (docs/ota-public-plan.md): every nRF52 env with a
|
||
# text console (OTA_ENVS) is built once more with -D FW_OTA=1 (admin-pushed
|
||
# update, FwUpdate), the observer ones as -observer-ota too. Each comes with a
|
||
# full .mcfw package and a delta from the same image of every kept earlier
|
||
# release (its zip's firmware.bin, checked against that release's SHA256SUMS);
|
||
# over the mesh a node takes only deltas, and none older than itself.
|
||
# Packages and SHA256SUMS are signed with OTA_SIGNING_KEY (meshcore-ota@tth-pub,
|
||
# tools/ota_allowed_signers); manifest.json lists what is there.
|
||
#
|
||
# dry_run: the same build anywhere (the private repo too), no release -- the
|
||
# result goes up as a workflow artifact. Delta bases always come from the
|
||
# public repo's releases.
|
||
name: pub-release
|
||
|
||
"on":
|
||
push:
|
||
branches: [main]
|
||
workflow_dispatch:
|
||
inputs:
|
||
ref:
|
||
description: "commit to build: FULL sha, branch or tag (checkout takes no short sha)"
|
||
required: false
|
||
default: "main"
|
||
replace:
|
||
description: "replace an existing release of this commit"
|
||
required: false
|
||
default: "false"
|
||
dry_run:
|
||
description: "build and package only, no release (runs in the private repo too)"
|
||
required: false
|
||
default: "false"
|
||
bases_repo:
|
||
description: "dry run only: take delta bases from this repo's releases instead (testing the delta path)"
|
||
required: false
|
||
default: ""
|
||
only:
|
||
description: "dry run only: build just these artifacts (e.g. Xiao_nrf52_repeater-ota), space separated"
|
||
required: false
|
||
default: ""
|
||
|
||
concurrency:
|
||
group: pub-release
|
||
cancel-in-progress: false
|
||
|
||
env:
|
||
GITEA: https://git.rfa.cz
|
||
KEEP: 5
|
||
# PUB_FLAGS / OBS_FLAGS: .github/fw-flags.sh (shared with the private mast
|
||
# release, which builds the same observer image). RAM 37-39 %, flash 41-58 %.
|
||
OBS_ENVS: >-
|
||
Xiao_nrf52_repeater SenseCap_Solar_repeater RAK_4631_repeater t1000e_repeater Heltec_t114_repeater
|
||
# nRF52 envs with a text console: also released as experimental -ota images
|
||
OTA_ENVS: >-
|
||
Xiao_nrf52_repeater Xiao_nrf52_room_server Xiao_nrf52_sensor SenseCap_Solar_repeater
|
||
RAK_4631_repeater RAK_4631_room_server t1000e_repeater Heltec_t114_repeater
|
||
PUB_REPO: tth-pub/meshcore-tth # where delta bases come from, dry run or not
|
||
ENVS: >-
|
||
Xiao_nrf52_repeater Xiao_nrf52_companion_radio_ble Xiao_nrf52_room_server Xiao_nrf52_sensor
|
||
SenseCap_Solar_repeater SenseCap_Solar_companion_radio_ble
|
||
RAK_4631_repeater RAK_4631_companion_radio_ble RAK_4631_room_server
|
||
t1000e_repeater t1000e_companion_radio_ble
|
||
Heltec_t114_repeater Heltec_t114_companion_radio_ble
|
||
Heltec_v3_repeater Heltec_v3_companion_radio_ble
|
||
|
||
jobs:
|
||
release:
|
||
if: github.repository == 'tth-pub/meshcore-tth' || github.event.inputs.dry_run == 'true'
|
||
runs-on: ubuntu-latest
|
||
steps:
|
||
- uses: actions/checkout@v4
|
||
with:
|
||
fetch-depth: 0
|
||
ref: ${{ github.event.inputs.ref || github.sha }}
|
||
|
||
- name: Commit and tag
|
||
id: src
|
||
env:
|
||
TOKEN: ${{ secrets.GITEA_TOKEN || github.token }}
|
||
REPLACE: ${{ github.event.inputs.replace }}
|
||
DRY: ${{ github.event.inputs.dry_run }}
|
||
run: |
|
||
set -euo pipefail
|
||
git fetch -q --tags
|
||
# the private repo carries no upstream release tags (the export brings
|
||
# them along): a dry run there fetches them, or the version base is "nover"
|
||
if [ "$DRY" = "true" ]; then
|
||
git fetch -q --no-tags https://github.com/meshcore-dev/MeshCore.git 'refs/tags/*:refs/tags/*'
|
||
fi
|
||
sha=$(git rev-parse HEAD)
|
||
# upstream base as tools/build_version.py finds it: "companion-v1.18.0" -> v1.18.0
|
||
desc=$(git describe --tags --abbrev=0 --match '*v[0-9]*' --exclude '*+tth*' --exclude 'backup/*' HEAD)
|
||
[[ $desc =~ v[0-9].* ]] && base=${BASH_REMATCH[0]} || base=$desc
|
||
# the COMMIT's date (Prague), so a rebuild of the same commit keeps its tag
|
||
day=$(TZ=Europe/Prague git show -s --format=%cd --date=format-local:%Y%m%d HEAD)
|
||
human=$(TZ=Europe/Prague git show -s --format=%cd --date=format-local:'%-d. %-m. %Y' HEAD)
|
||
api="$GITEA/api/v1/repos/$GITHUB_REPOSITORY"
|
||
auth="header = \"Authorization: token $TOKEN\""
|
||
enc() { jq -rn --arg s "$1" '$s|@uri'; }
|
||
# v1.18.0+tth.20261112, a second release of the day .2, ...
|
||
n=1
|
||
while :; do
|
||
tag="$base+tth.$day"
|
||
[ "$n" -eq 1 ] || tag="$tag.$n"
|
||
rel=$(curl -sS --config - "$api/releases/tags/$(enc "$tag")" <<<"$auth")
|
||
id=$(jq -r '.id // empty' <<<"$rel")
|
||
[ -n "$id" ] || break
|
||
if [ "$(jq -r .target_commitish <<<"$rel")" = "$sha" ]; then
|
||
if [ "$REPLACE" != "true" ]; then
|
||
echo "::error::release $tag already exists (id $id); set replace=true to rebuild it"
|
||
exit 1
|
||
fi
|
||
curl -sSf --config - -X DELETE "$api/releases/$id" <<<"$auth"
|
||
curl -sSf --config - -X DELETE "$api/tags/$(enc "$tag")" <<<"$auth" || true
|
||
echo "removed old $tag"
|
||
break
|
||
fi
|
||
n=$((n + 1))
|
||
done
|
||
title="$base+tth · $human"
|
||
[ "$n" -eq 1 ] || title="$title ($n)"
|
||
echo "release $tag: $title (commit $sha)"
|
||
{
|
||
echo "sha=$sha"
|
||
echo "tag=$tag"
|
||
echo "title=$title"
|
||
} >>"$GITHUB_OUTPUT"
|
||
|
||
- name: Setup Build Environment
|
||
uses: ./.github/actions/setup-build-environment
|
||
|
||
- name: Build and package
|
||
id: build
|
||
env:
|
||
TAG: ${{ steps.src.outputs.tag }}
|
||
OTA_SIGNING_KEY: ${{ secrets.OTA_SIGNING_KEY }}
|
||
TOKEN: ${{ secrets.GITEA_TOKEN || github.token }}
|
||
DRY: ${{ github.event.inputs.dry_run }}
|
||
BASES_REPO: ${{ github.event.inputs.bases_repo }}
|
||
ONLY: ${{ github.event.inputs.only }}
|
||
run: |
|
||
set -euo pipefail
|
||
source .github/fw-flags.sh
|
||
sha=$(git rev-parse --short=8 HEAD)
|
||
dist="$GITHUB_WORKSPACE/dist"
|
||
mkdir -p "$dist"
|
||
version=""
|
||
[ -n "$OTA_SIGNING_KEY" ] || { echo "::error::OTA_SIGNING_KEY secret missing"; exit 1; }
|
||
okey="$RUNNER_TEMP/ota_signing_key"
|
||
(umask 077 && printf '%s\n' "$OTA_SIGNING_KEY" >"$okey")
|
||
trap 'rm -f "$okey"' EXIT
|
||
pip install -q detools==0.53.0 cryptography
|
||
echo '{}' >"$dist/manifest.json"
|
||
# earlier public releases (newest first): delta bases for the -ota images
|
||
[ "$DRY" = "true" ] && [ -n "$BASES_REPO" ] && PUB_REPO=$BASES_REPO
|
||
[ "$DRY" = "true" ] || ONLY="" # a real release always builds everything
|
||
api="$GITEA/api/v1/repos/$PUB_REPO"
|
||
auth="header = \"Authorization: token $TOKEN\""
|
||
bases="$RUNNER_TEMP/bases"
|
||
mkdir -p "$bases"
|
||
curl -sSf --config - "$api/releases?limit=50" <<<"$auth" |
|
||
jq -c --arg t "$TAG" '[.[] | select(.tag_name | startswith("tth-") or test("[+]tth[.]")) | select(.tag_name != $t)]
|
||
| sort_by(.created_at) | reverse | .[]' >"$bases/releases.jsonl" || : >"$bases/releases.jsonl"
|
||
asset() { jq -r --arg n "$2" '.assets[] | select(.name == $n) | .browser_download_url' <<<"$1"; }
|
||
# ota_package <env> <artifact>: full package + deltas from earlier releases
|
||
ota_package() {
|
||
local env=$1 art=$2 b=".pio/build/$1" tags img rel ptag url dir out
|
||
tools/ota_check_ramfunc.sh "$env"
|
||
tags=$(grep -aoE 'MCFW-TAGS target=[!-~]+ epoch=[0-9]+' "$b/firmware.elf" | head -1)
|
||
img=$(sha256sum <"$b/firmware.bin" | cut -d' ' -f1)
|
||
python3 tools/ota_pack.py pack "$env" --key "$okey" --out "$dist/$art-$TAG.mcfw"
|
||
jq --arg a "$art" --arg z "$art-$TAG.zip" --arg f "$art-$TAG.mcfw" --arg i "$img" --arg t "${tags#MCFW-TAGS }" \
|
||
'.envs[$a] = {zip: $z, ota: {image_sha256: $i, tags: $t, full: $f, deltas: {}}}' \
|
||
"$dist/manifest.json" >"$dist/m.tmp" && mv "$dist/m.tmp" "$dist/manifest.json"
|
||
while read -r rel; do
|
||
ptag=$(jq -r .tag_name <<<"$rel")
|
||
url=$(asset "$rel" "$art-$ptag.zip")
|
||
[ -n "$url" ] || continue # that release had no such -ota image yet
|
||
dir="$bases/$ptag"
|
||
mkdir -p "$dir"
|
||
[ -f "$dir/SHA256SUMS" ] || curl -sSfL --config - -o "$dir/SHA256SUMS" "$(asset "$rel" SHA256SUMS)" <<<"$auth"
|
||
curl -sSfL --config - -o "$dir/$art-$ptag.zip" "$url" <<<"$auth"
|
||
(cd "$dir" && grep " $art-$ptag.zip\$" SHA256SUMS | sha256sum -c --quiet -)
|
||
unzip -p "$dir/$art-$ptag.zip" firmware.bin >"$dir/$art.bin"
|
||
out="$art-$TAG.from-$ptag.mcfw"
|
||
if python3 tools/ota_pack.py diff "$env" --base "$dir/$art.bin" --key "$okey" --out "$dist/$out"; then
|
||
jq --arg a "$art" --arg p "$ptag" --arg f "$out" --arg s "$(sha256sum <"$dir/$art.bin" | cut -d' ' -f1)" \
|
||
'.envs[$a].ota.deltas[$p] = {file: $f, base_sha256: $s}' \
|
||
"$dist/manifest.json" >"$dist/m.tmp" && mv "$dist/m.tmp" "$dist/manifest.json"
|
||
else
|
||
echo "::warning::$art: no delta from $ptag, full package only"
|
||
rm -f "$dist/$out"
|
||
fi
|
||
done <"$bases/releases.jsonl"
|
||
}
|
||
# build <env> <extra flags> <name suffix> [ota variant]; PlatformIO
|
||
# appends PLATFORMIO_BUILD_FLAGS after each env's flags: last -D wins
|
||
build() {
|
||
local env=$1 suffix=$3 variant=${4:-} b v
|
||
if [ -n "$ONLY" ] && [[ " $ONLY " != *" $env$suffix "* ]]; then return 0; fi
|
||
echo "::group::$env$suffix"
|
||
FW_OTA_VARIANT=$variant PLATFORMIO_BUILD_FLAGS="$PUB_FLAGS $2" pio run -e "$env"
|
||
b=".pio/build/$env"
|
||
if [ -f "$b/firmware.zip" ]; then # nRF52
|
||
python3 bin/uf2conv/uf2conv.py "$b/firmware.hex" -c -o "$b/firmware.uf2" -f 0xADA52840
|
||
cp "$b/firmware.uf2" "$dist/$env$suffix-$TAG.uf2"
|
||
cp "$b/firmware.zip" "$dist/$env$suffix-$TAG.zip"
|
||
v=$(grep -m1 -aoE 'v[0-9]+\.[0-9]+\.[0-9]+-tth[0-9a-f]+\+?' "$b/firmware.elf" || true)
|
||
case "$v" in *+) echo "::error::$env is dirty ($v)"; exit 1 ;; esac
|
||
[ -n "$version" ] || version="$v"
|
||
[ -z "$variant" ] || { unzip -p "$b/firmware.zip" firmware.bin >"$b/firmware.bin"; ota_package "$env" "$env$suffix"; }
|
||
else # ESP32
|
||
PLATFORMIO_BUILD_FLAGS="$PUB_FLAGS $2" pio run -t mergebin -e "$env"
|
||
cp "$b/firmware.bin" "$dist/$env$suffix-$TAG.bin"
|
||
cp "$b/firmware-merged.bin" "$dist/$env$suffix-$TAG-merged.bin"
|
||
fi
|
||
echo "::endgroup::"
|
||
}
|
||
for env in $ENVS; do build "$env" "" ""; done
|
||
for env in $OBS_ENVS; do build "$env" "$OBS_FLAGS" "-observer"; done
|
||
for env in $OTA_ENVS; do build "$env" "-D FW_OTA=1" "-ota" ota; done
|
||
for env in $OBS_ENVS; do build "$env" "$OBS_FLAGS -D FW_OTA=1" "-observer-ota" observer-ota; done
|
||
jq --arg c "$(git rev-parse HEAD)" --arg t "$TAG" '.commit = $c | .tag = $t' \
|
||
"$dist/manifest.json" >"$dist/m.tmp" && mv "$dist/m.tmp" "$dist/manifest.json"
|
||
cd "$dist"
|
||
sha256sum -- * >SHA256SUMS
|
||
ssh-keygen -q -Y sign -f "$okey" -n meshcore-ota SHA256SUMS
|
||
ssh-keygen -Y verify -f "$GITHUB_WORKSPACE/tools/ota_allowed_signers" -I meshcore-ota@tth-pub \
|
||
-n meshcore-ota -s SHA256SUMS.sig <SHA256SUMS
|
||
cat SHA256SUMS
|
||
echo "version=${version:-tth-$sha}" >>"$GITHUB_OUTPUT"
|
||
|
||
- name: Dry run artifact
|
||
if: github.event.inputs.dry_run == 'true'
|
||
uses: actions/upload-artifact@v4
|
||
with:
|
||
name: pub-release-dry-run
|
||
path: dist/
|
||
|
||
- name: Release
|
||
if: github.event.inputs.dry_run != 'true'
|
||
env:
|
||
TOKEN: ${{ secrets.GITEA_TOKEN || github.token }}
|
||
SHA: ${{ steps.src.outputs.sha }}
|
||
TAG: ${{ steps.src.outputs.tag }}
|
||
TITLE: ${{ steps.src.outputs.title }}
|
||
VERSION: ${{ steps.build.outputs.version }}
|
||
run: |
|
||
set -euo pipefail
|
||
api="$GITEA/api/v1/repos/$GITHUB_REPOSITORY"
|
||
auth="header = \"Authorization: token $TOKEN\""
|
||
readme="$GITEA/$GITHUB_REPOSITORY#o-tomto-forku-meshcore-tth"
|
||
note=$(cat <<EOF
|
||
- **BLE PIN \`123456\` a admin heslo \`password\` jsou zástupné.** Po nahrání je změň: \`password <nové>\` (nejvýš 15
|
||
znaků), \`ble pin <6 číslic>\`.
|
||
- **Výchozí nastavení pro český mesh** ([meshcore.cz](https://meshcore.cz/)): 869,432 MHz / 62,5 kHz / SF7 / CR5;
|
||
repeater a room server: zero-hop advert vypnutý, flood advert á 25 h, duty cycle 10 % (\`get dutycycle\`); repeater:
|
||
regiony \`cz\` a \`cs\`. **Platí jen pro nový nebo smazaný uzel** – nové nahrání ponechá uložené nastavení.
|
||
- **\`*-observer\`**: repeater s BLE konzolí a buffery \`rxlog\` / \`pktlog\` pro repeater observer. BLE je po nahrání
|
||
vypnuté: nejdřív \`ble pin\`, pak \`ble on\`.
|
||
- **RX duty cycle** (\`set radio.rxps\`, jen SX1262) je zabudovaný a vypnutý.
|
||
- **EXPERIMENTÁLNÍ \`*-ota\` / \`*-observer-ota\`**: totéž s aktualizací firmwaru od admina (\`fw ...\`, i přes
|
||
mesh). Ke každému plný balíček \`.mcfw\` (USB/BLE) a delta \`.from-<vydání>.mcfw\` od předchozích vydání –
|
||
přes mesh uzel přijme jen deltu a nikdy starší verzi. Balíčky i \`SHA256SUMS\` jsou podepsané klíčem
|
||
\`meshcore-ota@tth-pub\` (\`tools/ota_allowed_signers\`).
|
||
- Ověření: \`ver\` ukáže verzi z řádku *Verze v uzlu* výše. Co fork mění proti upstreamu: [README]($readme).
|
||
|
||
<details><summary>English</summary>
|
||
|
||
- **BLE PIN \`123456\` and admin password \`password\` are placeholders.** Change them after flashing: \`password
|
||
<new>\` (15 characters at most), \`ble pin <6 digits>\`.
|
||
- **Czech mesh defaults** ([meshcore.cz](https://meshcore.cz/)): 869.432 MHz / 62.5 kHz / SF7 / CR5; repeater and room
|
||
server: zero-hop advert off, flood advert every 25 h, 10 % duty cycle (\`get dutycycle\`); repeater: regions \`cz\`
|
||
and \`cs\`. **A fresh or erased node only** – a reflash keeps the saved settings.
|
||
- **\`*-observer\`**: repeater with a BLE console and the \`rxlog\` / \`pktlog\` rings for the repeater observer. BLE
|
||
is off after flashing: \`ble pin\` first, then \`ble on\`.
|
||
- **RX duty cycle** (\`set radio.rxps\`, SX1262 only) is built in and off.
|
||
- **EXPERIMENTAL \`*-ota\` / \`*-observer-ota\`**: the same with admin-pushed firmware update (\`fw ...\`, over the
|
||
mesh too). Each with a full \`.mcfw\` package (USB/BLE) and a delta \`.from-<release>.mcfw\` from earlier
|
||
releases -- over the mesh a node takes only a delta and never an older version. Packages and \`SHA256SUMS\`
|
||
are signed by \`meshcore-ota@tth-pub\` (\`tools/ota_allowed_signers\`).
|
||
- Check: \`ver\` shows the version from the *Verze v uzlu* (node version) line above. What the fork changes against
|
||
upstream: [README]($readme).
|
||
|
||
</details>
|
||
EOF
|
||
)
|
||
web="$GITEA/$GITHUB_REPOSITORY"
|
||
gh=https://github.com/meshcore-dev/MeshCore
|
||
max=60
|
||
# changelog against the newest older release that HEAD descends from
|
||
prev="" base=""
|
||
while read -r t c; do
|
||
if [ "$c" != "$SHA" ] && git merge-base --is-ancestor "$c" "$SHA" 2>/dev/null; then
|
||
prev=$t base=$c
|
||
break
|
||
fi
|
||
done < <(curl -sSf --config - "$api/releases?limit=50" <<<"$auth" |
|
||
jq -r --arg t "$TAG" 'map(select(.tag_name | startswith("tth-") or test("[+]tth[.]")) | select(.tag_name != $t))
|
||
| sort_by(.created_at) | reverse | .[] | "\(.tag_name) \(.target_commitish)"')
|
||
# no older release: the last 20 commits of our own line
|
||
[ -n "$base" ] || base=$(git rev-list --first-parent --max-count=21 "$SHA" | tail -1)
|
||
# ours: commits on our main itself (first parent); a merge of one of
|
||
# our own branches (feat/...) is unfolded into the branch's commits,
|
||
# an upstream merge is left to the upstream list below
|
||
fmt="- %s ([%h]($web/commit/%H))"
|
||
ours=""
|
||
for c in $(git log --first-parent --format=%H "$base..$SHA"); do
|
||
if git rev-parse -q --verify "$c^2" >/dev/null; then
|
||
git log -1 --format=%s "$c" | grep -q '^Merge upstream' && continue
|
||
ours+=$(git log --no-merges --format="$fmt" "$c^1..$c^2")$'\n'
|
||
else
|
||
ours+=$(git log -1 --format="$fmt" "$c")$'\n'
|
||
fi
|
||
done
|
||
ours=${ours%$'\n'}
|
||
# upstream: the first-parent line of each merged upstream branch,
|
||
# PR merges as their title, direct commits as their subject
|
||
declare -A seen=()
|
||
ups=()
|
||
for m in $(git log --first-parent --merges --grep='^Merge upstream' --format=%H "$base..$SHA"); do
|
||
for c in $(git log --first-parent --format=%H "$m^1..$m^2"); do
|
||
s=$(git log -1 --format=%s "$c")
|
||
if [[ $s =~ ^Merge\ pull\ request\ \#([0-9]+)\ from\ ([^/]+)/(.*)$ ]]; then
|
||
pr=${BASH_REMATCH[1]}
|
||
[ -z "${seen[$pr]:-}" ] || continue
|
||
seen[$pr]=1
|
||
t=$(git log -1 --format=%b "$c" | sed -n '/./{p;q}')
|
||
ups+=("- ${t:-${BASH_REMATCH[3]}} ([#$pr]($gh/pull/$pr), ${BASH_REMATCH[2]})")
|
||
elif [[ $s != Merge* ]]; then
|
||
[ -z "${seen[$c]:-}" ] || continue
|
||
seen[$c]=1
|
||
ups+=("- $s ([${c:0:7}]($gh/commit/$c))")
|
||
fi
|
||
done
|
||
done
|
||
n=${#ups[@]}
|
||
body=$(
|
||
echo "$TITLE"
|
||
echo
|
||
echo "Verze v uzlu · \`ver\`: $VERSION"
|
||
echo
|
||
if [ -n "$prev" ]; then
|
||
echo "Od předchozího vydání · since [$prev]($web/releases/tag/$(jq -rn --arg s "$prev" '$s|@uri'))"
|
||
echo
|
||
fi
|
||
echo "### Změny forku · fork changes"
|
||
echo "${ours:-- žádné · none}"
|
||
echo
|
||
echo "### Z upstreamu MeshCore · from upstream ($n)"
|
||
[ "$n" -gt 0 ] && printf '%s\n' "${ups[@]:0:$max}" || echo "- žádné · none"
|
||
[ "$n" -le "$max" ] || echo "- … a dalších $((n - max)) · and $((n - max)) more"
|
||
echo
|
||
echo "### Po flashi · after flashing"
|
||
echo
|
||
echo "$note"
|
||
echo
|
||
echo "commit $SHA, run $GITHUB_RUN_NUMBER"
|
||
)
|
||
jq -n --arg t "$TAG" --arg c "$SHA" --arg n "$TITLE" --arg b "$body" \
|
||
'{tag_name: $t, target_commitish: $c, name: $n, body: $b}' >"$RUNNER_TEMP/rel.json"
|
||
id=$(curl -sSf --config - -X POST -H 'Content-Type: application/json' \
|
||
--data-binary "@$RUNNER_TEMP/rel.json" "$api/releases" <<<"$auth" | jq -r .id)
|
||
for f in dist/*; do
|
||
curl -sSf --config - -X POST -F "attachment=@$f" \
|
||
"$api/releases/$id/assets?name=$(jq -rn --arg s "${f##*/}" '$s|@uri')" <<<"$auth" >/dev/null
|
||
echo "uploaded $(basename "$f")"
|
||
done
|
||
echo "released $TAG = $VERSION (id $id)"
|
||
# keep the newest $KEEP, oldest go (with their tags)
|
||
curl -sSf --config - "$api/releases?limit=50" <<<"$auth" |
|
||
jq -r --argjson k "$KEEP" 'map(select(.tag_name | startswith("tth-") or test("[+]tth[.]")))
|
||
| sort_by(.created_at) | reverse | .[$k:][] | "\(.id) \(.tag_name)"' |
|
||
while read -r old_id old_tag; do
|
||
curl -sSf --config - -X DELETE "$api/releases/$old_id" <<<"$auth"
|
||
curl -sSf --config - -X DELETE "$api/tags/$(jq -rn --arg s "$old_tag" '$s|@uri')" <<<"$auth" || true
|
||
echo "pruned $old_tag"
|
||
done
|