Build one plugin per Jellyfin generation (10.9, 10.11, 12)
🏗️ Build Plugin / build (push) Successful in 2m27s
Nightly Build / nightly-build (push) Failing after 1m18s
🧪 Test Plugin / test (push) Successful in 43s
🚀 Release Plugin / build-and-release (push) Failing after 1m12s

The single net8.0 build compiled against Jellyfin 10.9.11 still loads on
10.11 and 12, so channels and browsing keep working, but 10.11 changed
APIs in ways that only fail at runtime. A binary audit of the DLL against
the real server assemblies found 9 broken references on both 10.11 and
12 (none on 10.9/10.10):

- TaskTriggerInfo.Type became an enum. GetDefaultTriggers throws, so
  Jellyfin silently gives every SRF task a 24h fallback trigger. The
  recording scheduler therefore ran about once a day and scheduled
  recordings never started.
- ILibraryManager.GetItemList changed its return type: the expiration
  check crashed on every run.
- Jellyfin.Data.Entities.User moved (IUserManager.Users, GetUserData,
  SaveUserData, PlaybackProgressEventArgs.Users): resume cleanup returned
  500 and the playback-stop guard threw on every stop.

Jellyfin 12 also rejects the legacy X-Emby-Token header with an empty
401, which the recordings UI surfaced as "Unexpected end of JSON input".
The pages now send Authorization: MediaBrowser Token="...", verified on
10.9, 10.11 and 12.

The plugin now multi-targets net8.0/net9.0/net10.0 against Jellyfin
10.9.11/10.11.0/12.0.0 (the oldest package of each line, so each DLL
loads on every patch release of it), with JELLYFIN_10_11_OR_GREATER and
JELLYFIN_12_OR_GREATER for the differences. Trigger construction moves
into Utilities/TaskTriggers so the version switch lives in one place.

.gitea/scripts/build-plugins.sh builds one zip per generation. jprm has
no targetAbi flag, so it rewrites build.yaml per flavour and restores
it. Jellyfin installs the highest version whose targetAbi it satisfies,
so the flavour code goes into the last version segment:

  release v1.2.0 -> 1.2.0.9 / 1.2.0.11 / 1.2.0.12
  nightly        -> 1.0.<date>.<run>09 / 11 / 12

The PR, nightly and release workflows use the script and publish one
manifest entry per zip. Verified end to end against a three-entry
manifest: 10.11 installs the .11 build, 12.1 installs the .12 build.
The existing .NET 10 builder image builds all three unchanged.

Supporting changes: the test project multi-targets too, because jprm
publishes the whole solution for one framework at a time, and it drops
its Microsoft.Extensions.Logging 8.0.1 pin, which is a NU1605 downgrade
under the newer Jellyfin packages. CA1873 (new in the .NET 10 analyzers)
is silenced beside CA1848. The release manifest step checks out
origin/master like the nightly does since 7e1973a.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
This commit is contained in:
2026-09-24 01:42:38 +02:00
co-authored by Claude Opus 5.5
parent dc2dd09e49
commit 582c94f5f9
17 changed files with 251 additions and 152 deletions
+62
View File
@@ -0,0 +1,62 @@
#!/usr/bin/env bash
# Build one plugin zip per Jellyfin generation into ./artifacts.
#
# Jellyfin binds a plugin to the exact API it was compiled against, and 10.11 changed
# signatures that still compile but fail at runtime. So each generation gets its own DLL
# (see the TargetFrameworks comment in Jellyfin.Plugin.SRFPlay.csproj) and its own
# manifest entry. Jellyfin installs the highest version whose targetAbi is <= the server
# version, so the flavour code is folded into the version to keep them apart:
#
# net8.0 -> targetAbi 10.9.0.0 (Jellyfin 10.9 / 10.10) code 9
# net9.0 -> targetAbi 10.11.0.0 (Jellyfin 10.11) code 11
# net10.0 -> targetAbi 12.0.0.0 (Jellyfin 12) code 12
#
# Usage: build-plugins.sh <version-format>
# <version-format> is a printf format that receives the flavour code, e.g.
# "1.2.0.%d" -> 1.2.0.9, 1.2.0.11, 1.2.0.12 (release)
# "1.0.20260924.204%02d" -> 1.0.20260924.20409, ...20411, ...20412 (nightly)
#
# Writes artifacts/builds.tsv with one line per zip: version, targetAbi, zip path, md5.
set -euo pipefail
FORMAT="$1"
FLAVOURS=(
"net8.0 10.9.0.0 9"
"net9.0 10.11.0.0 11"
"net10.0 12.0.0.0 12"
)
mkdir -p artifacts
: > artifacts/builds.tsv
# jprm has no targetAbi flag and reads it from build.yaml, so rewrite it per flavour.
cp build.yaml build.yaml.orig
trap 'mv -f build.yaml.orig build.yaml' EXIT
for flavour in "${FLAVOURS[@]}"; do
read -r framework abi code <<< "$flavour"
# shellcheck disable=SC2059 # the format is the argument by design
version=$(printf "$FORMAT" "$code")
cp build.yaml.orig build.yaml
sed -i \
-e "s/^version:.*/version: \"${version}\"/" \
-e "s/^targetAbi:.*/targetAbi: \"${abi}\"/" \
-e "s/^framework:.*/framework: \"${framework}\"/" \
-e "s/^dotnet_framework:.*/dotnet_framework: \"${framework}\"/" \
build.yaml
echo ">> ${version}: ${framework}, targetAbi ${abi}"
jprm --verbosity=debug plugin build . --dotnet-framework "${framework}" --version "${version}"
zip="artifacts/srfplay_${version}.zip"
if [ ! -f "${zip}" ]; then
echo "jprm did not produce ${zip}" >&2
exit 1
fi
printf '%s\t%s\t%s\t%s\n' "${version}" "${abi}" "${zip}" "$(md5sum "${zip}" | awk '{print $1}')" >> artifacts/builds.tsv
done
cat artifacts/builds.tsv
+6 -17
View File
@@ -51,14 +51,10 @@ jobs:
LABEL="master"
fi
echo "version=${VERSION}" >> $GITHUB_OUTPUT
echo "format=${VERSION}%02d" >> $GITHUB_OUTPUT
echo "label=${LABEL}" >> $GITHUB_OUTPUT
echo "Build version: ${VERSION} (${LABEL})"
- name: Set build version
working-directory: build-${{ github.run_id }}
run: |
sed -i "s/^version:.*/version: \"${{ steps.version.outputs.version }}\"/" build.yaml
- name: Build solution
working-directory: build-${{ github.run_id }}
run: dotnet build Jellyfin.Plugin.SRFPlay.sln --configuration Release --no-restore --no-self-contained /m:1
@@ -67,23 +63,16 @@ jobs:
working-directory: build-${{ github.run_id }}
run: dotnet test Jellyfin.Plugin.SRFPlay.sln --no-build --configuration Release --verbosity normal
- name: Build Jellyfin Plugin
id: jprm
- name: Build Jellyfin Plugins
working-directory: build-${{ github.run_id }}
run: |
mkdir -p artifacts
jprm --verbosity=debug plugin build .
ARTIFACT=$(find . -name "*.zip" -type f -print -quit | sed 's|^\./||')
LATEST="artifacts/srfplay_latest.zip"
cp "${ARTIFACT}" "${LATEST}"
echo "artifact=${LATEST}" >> $GITHUB_OUTPUT
echo "Found artifact: ${ARTIFACT} -> ${LATEST}"
# One zip per Jellyfin generation (see .gitea/scripts/build-plugins.sh).
run: .gitea/scripts/build-plugins.sh "${{ steps.version.outputs.format }}"
- name: Upload build artifact
- name: Upload build artifacts
uses: actions/upload-artifact@v3
with:
name: srfplay-${{ steps.version.outputs.label }}-${{ steps.version.outputs.version }}
path: build-${{ github.run_id }}/${{ steps.jprm.outputs.artifact }}
path: build-${{ github.run_id }}/artifacts/*.zip
retention-days: 30
if-no-files-found: error
+31 -51
View File
@@ -27,18 +27,15 @@ jobs:
# Date-based nightly version: 1.0.<YYYYMMDD>.<run_number>
# The run_number suffix keeps multiple builds on the same day
# monotonically increasing so Jellyfin always offers the newest.
# Each Jellyfin generation gets its own build, so the last segment
# is <run_number><2-digit flavour code>, e.g. run 204 -> 20409/20411/20412
# (see .gitea/scripts/build-plugins.sh).
DATE=$(date -u +"%Y%m%d")
VERSION="1.0.${DATE}.${{ github.run_number }}"
echo "version=${VERSION}" >> $GITHUB_OUTPUT
echo "format=${VERSION}%02d" >> $GITHUB_OUTPUT
echo "Nightly version: ${VERSION}"
- name: Set build version
working-directory: build-${{ github.run_id }}
run: |
VERSION="${{ steps.version.outputs.version }}"
sed -i "s/^version:.*/version: \"${VERSION}\"/" build.yaml
cat build.yaml
- name: Restore dependencies
working-directory: build-${{ github.run_id }}
run: dotnet restore Jellyfin.Plugin.SRFPlay.sln
@@ -51,25 +48,9 @@ jobs:
working-directory: build-${{ github.run_id }}
run: dotnet test Jellyfin.Plugin.SRFPlay.sln --no-build --configuration Release --verbosity normal
- name: Build Jellyfin Plugin
id: jprm
- name: Build Jellyfin Plugins
working-directory: build-${{ github.run_id }}
run: |
mkdir -p artifacts
jprm --verbosity=debug plugin build .
ARTIFACT=$(find . -name "*.zip" -type f -print -quit | sed 's|^\./||')
ARTIFACT_NAME=$(basename "${ARTIFACT}")
echo "artifact=${ARTIFACT}" >> $GITHUB_OUTPUT
echo "artifact_name=${ARTIFACT_NAME}" >> $GITHUB_OUTPUT
echo "Found artifact: ${ARTIFACT}"
- name: Calculate checksum
id: checksum
working-directory: build-${{ github.run_id }}
run: |
CHECKSUM=$(md5sum "${{ steps.jprm.outputs.artifact }}" | awk '{print $1}')
echo "checksum=${CHECKSUM}" >> $GITHUB_OUTPUT
echo "Checksum: ${CHECKSUM}"
run: .gitea/scripts/build-plugins.sh "${{ steps.version.outputs.format }}"
- name: Delete existing nightly release
working-directory: build-${{ github.run_id }}
@@ -129,13 +110,15 @@ jobs:
exit 1
fi
# Upload plugin artifact
echo "Uploading plugin artifact..."
curl -f -X POST \
-H "Authorization: token ${GITEA_TOKEN}" \
-H "Content-Type: application/zip" \
--data-binary "@${{ steps.jprm.outputs.artifact }}" \
"${GITEA_URL}/api/v1/repos/${REPO_OWNER}/${REPO_NAME}/releases/${RELEASE_ID}/assets?name=${{ steps.jprm.outputs.artifact_name }}"
# Upload one plugin zip per Jellyfin generation
while IFS=$'\t' read -r _ _ ZIP _; do
echo "Uploading ${ZIP}..."
curl -f -X POST \
-H "Authorization: token ${GITEA_TOKEN}" \
-H "Content-Type: application/zip" \
--data-binary "@${ZIP}" \
"${GITEA_URL}/api/v1/repos/${REPO_OWNER}/${REPO_NAME}/releases/${RELEASE_ID}/assets?name=$(basename "${ZIP}")"
done < artifacts/builds.tsv
# Upload build.yaml
echo "Uploading build.yaml..."
@@ -155,12 +138,10 @@ jobs:
REPO_OWNER="${{ github.repository_owner }}"
REPO_NAME="${{ github.event.repository.name }}"
GITEA_URL="${{ github.server_url }}"
VERSION="${{ steps.version.outputs.version }}"
CHECKSUM="${{ steps.checksum.outputs.checksum }}"
ARTIFACT_NAME="${{ steps.jprm.outputs.artifact_name }}"
TIMESTAMP=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
DOWNLOAD_URL="${GITEA_URL}/${REPO_OWNER}/${REPO_NAME}/releases/download/latest/${ARTIFACT_NAME}"
SHORT_SHA=$(echo "${{ github.sha }}" | cut -c1-7)
# builds.tsv is read before the checkout below replaces the tree.
BUILDS=$(cat artifacts/builds.tsv)
git config user.name "Gitea Actions"
git config user.email "actions@gitea.tourolle.paris"
@@ -178,25 +159,24 @@ jobs:
# edits must be master, not whatever this build started from.
git checkout -B master origin/master
NEW_VERSION=$(cat <<EOF
{
"version": "${VERSION}",
"changelog": "Nightly build ${VERSION} (${SHORT_SHA})",
"targetAbi": "10.9.0.0",
"sourceUrl": "${DOWNLOAD_URL}",
"checksum": "${CHECKSUM}",
"timestamp": "${TIMESTAMP}"
}
EOF
)
# One entry per Jellyfin generation; each server installs the newest
# entry whose targetAbi it satisfies.
NEW_VERSIONS=$(echo "${BUILDS}" | jq -R -s \
--arg url "${GITEA_URL}/${REPO_OWNER}/${REPO_NAME}/releases/download/latest" \
--arg sha "${SHORT_SHA}" --arg ts "${TIMESTAMP}" \
'split("\n") | map(select(length > 0) | split("\t")
| {version: .[0], changelog: "Nightly build \(.[0]) (\($sha))", targetAbi: .[1],
sourceUrl: "\($url)/\(.[2] | split("/") | last)", checksum: .[3], timestamp: $ts})
| reverse')
# Prepend the new build and keep only the most recent 5 nightlies.
jq --argjson newver "${NEW_VERSION}" \
'.[0].versions = ([$newver] + .[0].versions)[0:5]' \
# Prepend the new builds and keep only the most recent 5 nightlies
# (3 entries each, one per Jellyfin generation).
jq --argjson newvers "${NEW_VERSIONS}" \
'.[0].versions = ($newvers + .[0].versions)[0:15]' \
manifest-nightly.json > manifest.tmp && mv manifest.tmp manifest-nightly.json
git add manifest-nightly.json
git commit -m "Nightly: ${VERSION} (${SHORT_SHA})" || echo "No changes to commit"
git commit -m "Nightly: ${{ steps.version.outputs.version }} (${SHORT_SHA})" || echo "No changes to commit"
git push origin master
- name: Cleanup
+28 -48
View File
@@ -35,13 +35,6 @@ jobs:
echo "version_number=${VERSION#v}" >> $GITHUB_OUTPUT
echo "Building version: ${VERSION}"
- name: Update build.yaml with version
working-directory: release-${{ github.run_id }}
run: |
VERSION="${{ steps.get_version.outputs.version_number }}"
sed -i "s/^version:.*/version: \"${VERSION}\"/" build.yaml
cat build.yaml
- name: Cache NuGet packages
uses: actions/cache@v3
with:
@@ -61,25 +54,11 @@ jobs:
working-directory: release-${{ github.run_id }}
run: dotnet test Jellyfin.Plugin.SRFPlay.sln --no-build --configuration Release --verbosity normal
- name: Build Jellyfin Plugin
id: jprm
- name: Build Jellyfin Plugins
working-directory: release-${{ github.run_id }}
run: |
mkdir -p artifacts
jprm --verbosity=debug plugin build ./
ARTIFACT=$(find . -name "*.zip" -type f -print -quit | sed 's|^\./||')
ARTIFACT_NAME=$(basename "${ARTIFACT}")
echo "artifact=${ARTIFACT}" >> $GITHUB_OUTPUT
echo "artifact_name=${ARTIFACT_NAME}" >> $GITHUB_OUTPUT
echo "Found artifact: ${ARTIFACT}"
- name: Calculate checksum
id: checksum
working-directory: release-${{ github.run_id }}
run: |
CHECKSUM=$(md5sum "${{ steps.jprm.outputs.artifact }}" | awk '{print $1}')
echo "checksum=${CHECKSUM}" >> $GITHUB_OUTPUT
echo "Checksum: ${CHECKSUM}"
# v1.2.0 -> 1.2.0.9 / 1.2.0.11 / 1.2.0.12, one per Jellyfin generation
# (see .gitea/scripts/build-plugins.sh).
run: .gitea/scripts/build-plugins.sh "${{ steps.get_version.outputs.version_number }}.%d"
- name: Create Release
working-directory: release-${{ github.run_id }}
@@ -111,13 +90,15 @@ jobs:
exit 1
fi
# Upload plugin artifact
echo "Uploading plugin artifact..."
curl -f -X POST \
-H "Authorization: token ${GITEA_TOKEN}" \
-H "Content-Type: application/zip" \
--data-binary "@${{ steps.jprm.outputs.artifact }}" \
"${GITEA_URL}/api/v1/repos/${REPO_OWNER}/${REPO_NAME}/releases/${RELEASE_ID}/assets?name=${{ steps.jprm.outputs.artifact_name }}"
# Upload one plugin zip per Jellyfin generation
while IFS=$'\t' read -r _ _ ZIP _; do
echo "Uploading ${ZIP}..."
curl -f -X POST \
-H "Authorization: token ${GITEA_TOKEN}" \
-H "Content-Type: application/zip" \
--data-binary "@${ZIP}" \
"${GITEA_URL}/api/v1/repos/${REPO_OWNER}/${REPO_NAME}/releases/${RELEASE_ID}/assets?name=$(basename "${ZIP}")"
done < artifacts/builds.tsv
# Upload build.yaml
echo "Uploading build.yaml..."
@@ -139,29 +120,28 @@ jobs:
REPO_NAME="${{ github.event.repository.name }}"
GITEA_URL="${{ github.server_url }}"
VERSION="${{ steps.get_version.outputs.version_number }}"
CHECKSUM="${{ steps.checksum.outputs.checksum }}"
ARTIFACT_NAME="${{ steps.jprm.outputs.artifact_name }}"
TIMESTAMP=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
DOWNLOAD_URL="${GITEA_URL}/${REPO_OWNER}/${REPO_NAME}/releases/download/${{ steps.get_version.outputs.version }}/${ARTIFACT_NAME}"
# builds.tsv is read before the checkout below replaces the tree.
BUILDS=$(cat artifacts/builds.tsv)
git config user.name "Gitea Actions"
git config user.email "actions@gitea.tourolle.paris"
git fetch origin master
git checkout master
# -B against origin/master for the same reason as the nightly: a bare
# `checkout master` edits the manifest on a stale base if master moved.
git checkout -B master origin/master
NEW_VERSION=$(cat <<EOF
{
"version": "${VERSION}",
"changelog": "Release ${VERSION}",
"targetAbi": "10.9.0.0",
"sourceUrl": "${DOWNLOAD_URL}",
"checksum": "${CHECKSUM}",
"timestamp": "${TIMESTAMP}"
}
EOF
)
# One entry per Jellyfin generation; each server installs the newest
# entry whose targetAbi it satisfies.
NEW_VERSIONS=$(echo "${BUILDS}" | jq -R -s \
--arg url "${GITEA_URL}/${REPO_OWNER}/${REPO_NAME}/releases/download/${{ steps.get_version.outputs.version }}" \
--arg release "${VERSION}" --arg ts "${TIMESTAMP}" \
'split("\n") | map(select(length > 0) | split("\t")
| {version: .[0], changelog: "Release \($release)", targetAbi: .[1],
sourceUrl: "\($url)/\(.[2] | split("/") | last)", checksum: .[3], timestamp: $ts})
| reverse')
jq --argjson newver "${NEW_VERSION}" '.[0].versions = [$newver] + .[0].versions' manifest.json > manifest.tmp && mv manifest.tmp manifest.json
jq --argjson newvers "${NEW_VERSIONS}" '.[0].versions = $newvers + .[0].versions' manifest.json > manifest.tmp && mv manifest.tmp manifest.json
git add manifest.json
git commit -m "Update manifest.json for version ${VERSION}"
git push origin master