pxsteamdl 0.4.0__tar.gz

pxsteamdl-0.4.0/.clang-format

@@ -0,0 +1,8 @@
+# Google C++ style, lightened: 2-space indent, 120 columns (see CONTRIBUTING.md).
+BasedOnStyle: Google
+IndentWidth: 2
+ColumnLimit: 120
+AccessModifierOffset: -1
+DerivePointerAlignment: false
+PointerAlignment: Left
+IncludeBlocks: Preserve

pxsteamdl-0.4.0/.clang-tidy

@@ -0,0 +1,29 @@
+# Naming rules of the project's lightened Google C++ style (see CONTRIBUTING.md).
+Checks: '-*,readability-identifier-naming'
+WarningsAsErrors: '*'
+HeaderFilterRegex: '(src|include|cli|python|tests)/'
+CheckOptions:
+  readability-identifier-naming.NamespaceCase: lower_case
+  readability-identifier-naming.ClassCase: CamelCase
+  readability-identifier-naming.StructCase: CamelCase
+  readability-identifier-naming.EnumCase: CamelCase
+  readability-identifier-naming.TypeAliasCase: CamelCase
+  readability-identifier-naming.TemplateParameterCase: CamelCase
+  readability-identifier-naming.FunctionCase: CamelCase
+  readability-identifier-naming.FunctionIgnoredRegexp: '^main$'
+  readability-identifier-naming.MethodCase: camelBack
+  readability-identifier-naming.VariableCase: lower_case
+  readability-identifier-naming.ParameterCase: lower_case
+  readability-identifier-naming.MemberCase: lower_case
+  readability-identifier-naming.PrivateMemberCase: camelBack
+  readability-identifier-naming.PrivateMemberPrefix: 'm_'
+  readability-identifier-naming.ProtectedMemberCase: camelBack
+  readability-identifier-naming.ProtectedMemberPrefix: 'm_'
+  readability-identifier-naming.ConstexprVariableCase: CamelCase
+  readability-identifier-naming.ConstexprVariablePrefix: 'k'
+  readability-identifier-naming.StaticConstantCase: CamelCase
+  readability-identifier-naming.StaticConstantPrefix: 'k'
+  readability-identifier-naming.EnumConstantCase: CamelCase
+  readability-identifier-naming.EnumConstantPrefix: 'k'
+  readability-identifier-naming.GlobalConstantCase: CamelCase
+  readability-identifier-naming.GlobalConstantPrefix: 'k'

pxsteamdl-0.4.0/.github/scripts/update-ca-bundle.sh

@@ -0,0 +1,55 @@
+#!/usr/bin/env bash
+# SPDX-License-Identifier: LGPL-3.0-or-later
+# Looks for a Mozilla CA bundle (as extracted by curl) that is newer than the one pinned in CMakeLists.txt and, if
+# there is one, rewrites the pinned date and SHA-256 there. Writes "date=<new date>" to $GITHUB_OUTPUT when it did.
+# CA_BASE_URL and CMAKE_FILE exist for testing.
+set -euo pipefail
+
+base=${CA_BASE_URL:-https://curl.se/ca}
+cmake_file=${CMAKE_FILE:-CMakeLists.txt}
+work=$(mktemp -d)
+trap 'rm -rf "$work"' EXIT
+
+current=$(sed -n 's/^set(PXSTEAMDL_CA_BUNDLE_DATE \([0-9-]*\))$/\1/p' "$cmake_file")
+if [ -z "$current" ]; then
+  echo "::error::No PXSTEAMDL_CA_BUNDLE_DATE in $cmake_file" >&2
+  exit 1
+fi
+
+# The newest bundle names the date it was extracted on in its header: "## Certificate data from Mozilla as of: ...".
+curl -fsSL "$base/cacert.pem" -o "$work/latest.pem"
+as_of=$(sed -n 's/^## Certificate data from Mozilla as of: //p' "$work/latest.pem" | head -n 1)
+if [ -z "$as_of" ]; then
+  echo "::error::The bundle has no 'Certificate data from Mozilla as of' line" >&2
+  exit 1
+fi
+new=$(date -u -d "$as_of" +%F)
+if [[ ! "$new" > "$current" ]]; then
+  echo "The pinned bundle ($current) is up to date; the newest is $new"
+  exit 0
+fi
+
+# The pin names a file by date, so fetch that very file and check that it is what the newest bundle is.
+if ! curl -fsSL "$base/cacert-$new.pem" -o "$work/dated.pem"; then
+  echo "::error::$base/cacert-$new.pem does not exist; the date in the bundle's header may not be its file name" >&2
+  exit 1
+fi
+hash=$(sha256sum "$work/dated.pem" | cut -d' ' -f1)
+if [ "$hash" != "$(sha256sum "$work/latest.pem" | cut -d' ' -f1)" ]; then
+  echo "::error::cacert-$new.pem differs from cacert.pem" >&2
+  exit 1
+fi
+if [ "$(grep -c 'BEGIN CERTIFICATE' "$work/dated.pem")" -lt 50 ]; then
+  echo "::error::cacert-$new.pem has suspiciously few certificates" >&2
+  exit 1
+fi
+
+# The hash line to change is the one of the cacert package; other packages have theirs.
+sed -i "s/^set(PXSTEAMDL_CA_BUNDLE_DATE .*/set(PXSTEAMDL_CA_BUNDLE_DATE $new)/" "$cmake_file"
+sed -i "/NAME cacert/,/DOWNLOAD_NO_EXTRACT/ s/SHA256=[0-9a-f]\{64\}/SHA256=$hash/" "$cmake_file"
+if ! grep -q "SHA256=$hash" "$cmake_file" || ! grep -q "PXSTEAMDL_CA_BUNDLE_DATE $new)" "$cmake_file"; then
+  echo "::error::Could not update $cmake_file" >&2
+  exit 1
+fi
+echo "Pinned bundle: $current -> $new ($hash)"
+echo "date=$new" >> "${GITHUB_OUTPUT:-/dev/null}"

pxsteamdl-0.4.0/.github/smoke_test.py

@@ -0,0 +1,66 @@
+# SPDX-License-Identifier: LGPL-3.0-or-later
+"""Downloads small Workshop items through the installed package, synchronously and with asyncio."""
+import asyncio
+import faulthandler
+import pathlib
+import tempfile
+import threading
+
+import pxsteamdl
+
+ITEMS = [2009463077, 818773962]  # Harmony, HugsLib
+
+# A hang fails the job with a traceback of every thread instead of running into the CI timeout.
+faulthandler.dump_traceback_later(300, exit=True)
+
+with tempfile.TemporaryDirectory() as tmp:
+    root = pathlib.Path(tmp)
+
+    caller = threading.get_ident()
+    resolved = []
+    first_progress = {}
+
+    def on_resolved(info):
+        assert threading.get_ident() == caller
+        assert info.item_id not in first_progress, "progress before on_resolved"
+        resolved.append(info.item_id)
+
+    def on_progress(p):
+        first_progress.setdefault(p.item_id, len(resolved))
+
+    results = pxsteamdl.Client().download(ITEMS, root / "sync", on_progress=on_progress, on_resolved=on_resolved)
+    print(results)
+    assert resolved == ITEMS, resolved
+    for result in results:
+        assert result.ok, result.error
+        assert result.error_kind == pxsteamdl.ErrorKind.NONE
+        assert (result.path / "About" / "About.xml").is_file()
+        assert result.downloaded_bytes > 0 and result.unpacked_bytes > 0
+
+    # A second run finds everything in place and fetches nothing; a repeated ID is answered each time.
+    again = pxsteamdl.Client().download(ITEMS + ITEMS[:1], root / "sync")
+    assert [r.item_id for r in again] == ITEMS + ITEMS[:1]
+    assert all(r.ok and r.downloaded_bytes == 0 and r.unpacked_bytes == 0 for r in again), again
+
+    # An item that does not exist is not found (or at least refused), and says so by kind, not by wording.
+    missing = pxsteamdl.Client().download([1], root / "missing")[0]
+    assert not missing.ok and missing.error_kind in (pxsteamdl.ErrorKind.NOT_FOUND, pxsteamdl.ErrorKind.REJECTED), missing
+    assert not missing.cancelled
+
+    async def download_async():
+        client = await pxsteamdl.AsyncClient.create()
+        loop_thread = threading.get_ident()
+        calls = []
+
+        def on_progress(p):
+            assert threading.get_ident() == loop_thread
+            calls.append(p)
+
+        results = await client.download(ITEMS[:1], root / "async", on_progress=on_progress)
+        print(results)
+        assert results[0].ok, results[0].error
+        assert (results[0].path / "About" / "About.xml").is_file()
+        assert calls
+
+    asyncio.run(download_async())
+print("smoke test passed")

pxsteamdl-0.4.0/.github/workflows/ci.yml

@@ -0,0 +1,140 @@
+name: CI
+
+# Pull requests are checked by the pull_request event; push covers main only, so a PR commit runs once and tags
+# (built by the Release workflow) do not rerun CI. The smoke tests download real items, so a failure may be Steam's
+# and not the code's: a run on main every day shows whether main itself is fine.
+on:
+  push:
+    branches: [main]
+  pull_request:
+  workflow_dispatch:
+  schedule:
+    - cron: "17 5 * * *"
+
+# A new push to a PR supersedes its running check; every commit on main keeps its own run.
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
+  cancel-in-progress: ${{ github.event_name == 'pull_request' }}
+
+jobs:
+  build:
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, windows-latest, macos-latest]
+    runs-on: ${{ matrix.os }}
+    env:
+      CPM_SOURCE_CACHE: ${{ github.workspace }}/.cpm-cache
+    defaults:
+      run:
+        shell: bash
+    steps:
+      - uses: actions/checkout@v7
+
+      - uses: actions/cache@v6
+        with:
+          path: .cpm-cache
+          key: cpm-${{ runner.os }}-${{ hashFiles('CMakeLists.txt') }}
+
+      - uses: ilammy/msvc-dev-cmd@v1.13.0
+        if: runner.os == 'Windows'
+
+      - name: Install Ninja
+        if: runner.os == 'macOS'
+        run: brew install ninja
+
+      - name: Configure
+        run: cmake -S . -B build -G Ninja -DCMAKE_BUILD_TYPE=Release -DPXSTEAMDL_BUILD_TESTS=ON -DPXSTEAMDL_BUILD_EXAMPLES=ON
+
+      - name: Build
+        run: cmake --build build
+
+      - name: Unit tests
+        run: ctest --test-dir build --output-on-failure
+
+      # Style (see CONTRIBUTING.md): formatting and naming, checked once with pinned LLVM 18 tools.
+      - name: clang-format
+        if: runner.os == 'Linux'
+        run: clang-format-18 --dry-run --Werror src/*.cpp src/*.hpp include/pxsteamdl/*.hpp cli/main.cpp python/pxsteamdl.cpp tests/*.cpp tests/*.hpp tests/fakes/*.?pp
+
+      - name: clang-tidy
+        if: runner.os == 'Linux'
+        run: clang-tidy-18 -p build --quiet src/*.cpp cli/main.cpp tests/*.cpp tests/fakes/*.cpp
+
+      # The installed package must be complete: a separate project builds against it with find_package.
+      - name: Install and use as a package
+        run: |
+          cmake --install build --prefix "$RUNNER_TEMP/prefix"
+          cmake -S tests/install_consumer -B "$RUNNER_TEMP/consumer" -G Ninja -DCMAKE_BUILD_TYPE=Release \
+            -DCMAKE_PREFIX_PATH="$RUNNER_TEMP/prefix"
+          cmake --build "$RUNNER_TEMP/consumer"
+          expected=$(sed -n 's/^project(PxSteamDL VERSION \([0-9.]*\).*/\1/p' CMakeLists.txt)
+          test "$("$RUNNER_TEMP/consumer/consumer" | tr -d '\r')" = "$expected"
+          "$RUNNER_TEMP/prefix/bin/pxsteamdl" --version
+
+      - name: Binary size
+        run: |
+          exe=build/pxsteamdl${{ runner.os == 'Windows' && '.exe' || '' }}
+          ls -l "$exe"
+          if [ "$RUNNER_OS" != Windows ]; then cp "$exe" stripped && strip stripped && ls -l stripped; fi
+          if [ "$RUNNER_OS" = Linux ]; then ldd "$exe"; fi
+          if [ "$RUNNER_OS" = macOS ]; then otool -L "$exe"; fi
+
+      - name: CLI check
+        run: |
+          status=0
+          ./build/pxsteamdl || status=$?
+          test "$status" -eq 2
+          # The version printed is the one in CMakeLists.txt.
+          expected=$(sed -n 's/^project(PxSteamDL VERSION \([0-9.]*\).*/\1/p' CMakeLists.txt)
+          test "$(./build/pxsteamdl --version | tr -d '\r')" = "pxsteamdl $expected"
+
+      # Downloads real items from Steam. The timeout turns a hang (seen once on a Windows runner) into a failure.
+      - name: Smoke test
+        timeout-minutes: 10
+        run: |
+          mods="$RUNNER_TEMP/mods"
+          ./build/pxsteamdl -o "$mods" 2009463077 818773962
+          test -f "$mods/2009463077/About/About.xml"
+          test -f "$mods/818773962/About/About.xml"
+          # A damaged file must be replaced (rename over an existing file).
+          expected=$(cksum < "$mods/2009463077/About/About.xml")
+          echo damaged >> "$mods/2009463077/About/About.xml"
+          ./build/pxsteamdl -o "$mods" 2009463077
+          test "$(cksum < "$mods/2009463077/About/About.xml")" = "$expected"
+          # An unknown item fails alone, with exit code 1 and a readable reason.
+          status=0
+          ./build/pxsteamdl -o "$mods" 2009463077 1 > "$RUNNER_TEMP/out.txt" || status=$?
+          cat "$RUNNER_TEMP/out.txt"
+          test "$status" -eq 1
+          grep -q "Steam rejected the item: not found (EResult 9)" "$RUNNER_TEMP/out.txt"
+
+  python:
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, windows-latest, macos-latest]
+    runs-on: ${{ matrix.os }}
+    env:
+      CPM_SOURCE_CACHE: ${{ github.workspace }}/.cpm-cache
+    steps:
+      - uses: actions/checkout@v7
+
+      - uses: actions/setup-python@v7
+        with:
+          python-version: "3.13"
+
+      - uses: actions/cache@v6
+        with:
+          path: .cpm-cache
+          key: cpm-python-${{ runner.os }}-${{ hashFiles('CMakeLists.txt') }}
+
+      - name: Install package
+        run: python -m pip install .
+
+      - name: Import check
+        run: python -c "import pxsteamdl; print(pxsteamdl.__version__, pxsteamdl.Client, pxsteamdl.AsyncClient, pxsteamdl.CancelToken)"
+
+      - name: Smoke test
+        timeout-minutes: 10
+        run: python -u .github/smoke_test.py

pxsteamdl-0.4.0/.github/workflows/release.yml

@@ -0,0 +1,226 @@
+name: Release
+
+on:
+  push:
+    tags: ["v*"]
+  workflow_dispatch:
+    inputs:
+      publish:
+        description: "Publish GitHub Release (if false, only builds artifacts)"
+        type: boolean
+        default: false
+      tag_name:
+        description: "Release tag (e.g. v0.1.0, required if publish is true)"
+        type: string
+        default: ""
+
+permissions:
+  contents: write
+
+jobs:
+  check:
+    name: Check the version
+    if: (github.event_name == 'push' && startsWith(github.ref, 'refs/tags/v')) || (github.event_name == 'workflow_dispatch' && inputs.publish && inputs.tag_name != '')
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v7
+
+      # A release is tagged vX.Y.Z, with X.Y.Z in project(PxSteamDL VERSION ...) and a section in CHANGELOG.md.
+      - name: Tag, version and changelog agree
+        shell: bash
+        env:
+          TAG: ${{ github.event.inputs.tag_name || github.ref_name }}
+        run: |
+          expected=$(sed -n 's/^project(PxSteamDL VERSION \([0-9.]*\).*/\1/p' CMakeLists.txt)
+          if [ "$TAG" != "v$expected" ]; then
+            echo "::error::Tag $TAG does not match the version $expected in CMakeLists.txt"
+            exit 1
+          fi
+          if ! grep -q "^## \[$expected\] - " CHANGELOG.md; then
+            echo "::error::CHANGELOG.md has no section for $expected"
+            exit 1
+          fi
+
+  binaries:
+    name: binary (${{ matrix.os }})
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: ubuntu-latest
+            artifact_name: pxsteamdl-linux-x86_64
+            archive_name: pxsteamdl-linux-x86_64.tar.gz
+            pack_type: tar
+          - os: macos-latest
+            artifact_name: pxsteamdl-macos-arm64
+            archive_name: pxsteamdl-macos-arm64.tar.gz
+            pack_type: tar
+          - os: windows-latest
+            artifact_name: pxsteamdl-windows-x64
+            archive_name: pxsteamdl-windows-x64.zip
+            pack_type: zip
+    runs-on: ${{ matrix.os }}
+    steps:
+      - uses: actions/checkout@v7
+
+      - uses: actions/cache@v6
+        with:
+          path: .cpm-cache
+          key: cpm-bin-${{ matrix.os }}-${{ hashFiles('CMakeLists.txt') }}
+
+      - uses: ilammy/msvc-dev-cmd@v1.13.0
+        if: matrix.os == 'windows-latest'
+
+      - name: Install Ninja
+        if: matrix.os != 'windows-latest'
+        run: |
+          if [ "${{ runner.os }}" = "Linux" ]; then
+            sudo apt-get update -qy && sudo apt-get install -qy ninja-build
+          else
+            brew install ninja
+          fi
+
+      - name: Configure
+        env:
+          CPM_SOURCE_CACHE: ${{ github.workspace }}/.cpm-cache
+        run: cmake -S . -B build -G Ninja -DCMAKE_BUILD_TYPE=Release -DPXSTEAMDL_BUILD_CLI=ON -DPXSTEAMDL_BUILD_PYTHON=OFF
+
+      - name: Build CLI
+        run: cmake --build build --target pxsteamdl-cli --config Release
+
+      - name: Strip binary (Linux/macOS)
+        if: matrix.pack_type == 'tar'
+        run: |
+          if [ "${{ runner.os }}" = "Linux" ]; then
+            strip -s build/pxsteamdl
+          else
+            strip build/pxsteamdl
+          fi
+
+      - name: Package (tar.gz)
+        if: matrix.pack_type == 'tar'
+        run: |
+          mkdir -p staging/${{ matrix.artifact_name }} dist
+          cp build/pxsteamdl COPYING COPYING.LESSER README.md staging/${{ matrix.artifact_name }}/
+          tar -czvf dist/${{ matrix.archive_name }} -C staging ${{ matrix.artifact_name }}
+
+      - name: Package (zip)
+        if: matrix.pack_type == 'zip'
+        shell: pwsh
+        run: |
+          New-Item -ItemType Directory -Path staging\${{ matrix.artifact_name }} -Force
+          Copy-Item build\pxsteamdl.exe, COPYING, COPYING.LESSER, README.md staging\${{ matrix.artifact_name }}\
+          New-Item -ItemType Directory -Path dist -Force
+          Compress-Archive -Path staging\${{ matrix.artifact_name }} -DestinationPath dist\${{ matrix.archive_name }}
+
+      - uses: actions/upload-artifact@v7
+        with:
+          name: binary-${{ matrix.artifact_name }}
+          path: dist/*
+          if-no-files-found: error
+
+  wheels:
+    name: wheels (${{ matrix.os }})
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, windows-latest, macos-latest]
+    runs-on: ${{ matrix.os }}
+    env:
+      CIBW_ENVIRONMENT_LINUX: CPM_SOURCE_CACHE=/tmp/cpm-cache
+      CPM_SOURCE_CACHE: ${{ github.workspace }}/.cpm-cache
+    steps:
+      - uses: actions/checkout@v7
+
+      - uses: actions/cache@v6
+        if: runner.os != 'Linux'
+        with:
+          path: .cpm-cache
+          key: cpm-wheels-${{ runner.os }}-${{ hashFiles('CMakeLists.txt') }}
+
+      - uses: pypa/cibuildwheel@v4.2.1
+
+      - name: Wheel sizes
+        shell: bash
+        run: ls -l wheelhouse
+
+      - uses: actions/upload-artifact@v7
+        with:
+          name: wheels-${{ runner.os }}
+          path: wheelhouse/*.whl
+          if-no-files-found: error
+
+  sdist:
+    name: sdist
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v7
+
+      - name: Build sdist
+        run: pipx run build --sdist
+
+      - uses: actions/upload-artifact@v7
+        with:
+          name: sdist
+          path: dist/*.tar.gz
+          if-no-files-found: error
+
+  pypi:
+    name: Publish to PyPI
+    if: github.event_name == 'push' && startsWith(github.ref, 'refs/tags/v')
+    needs: [check, wheels, sdist]
+    runs-on: ubuntu-latest
+    environment: pypi
+    permissions:
+      id-token: write
+    steps:
+      - uses: actions/download-artifact@v8
+        with:
+          path: dist
+          pattern: "{wheels-*,sdist}"
+          merge-multiple: true
+
+      - name: List distributions
+        run: ls -l dist
+
+      # Trusted publishing: no API token; the pending publisher on pypi.org names this workflow and the pypi environment.
+      - uses: pypa/gh-action-pypi-publish@release/v1
+
+  release:
+    name: Publish Release
+    if: (github.event_name == 'push' && startsWith(github.ref, 'refs/tags/v')) || (github.event_name == 'workflow_dispatch' && inputs.publish && inputs.tag_name != '')
+    needs: [check, binaries, wheels, sdist]
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+    steps:
+      - uses: actions/checkout@v7
+
+      # The release notes are the changelog section of this version.
+      - name: Release notes
+        shell: bash
+        run: |
+          version=$(sed -n 's/^project(PxSteamDL VERSION \([0-9.]*\).*/\1/p' CMakeLists.txt)
+          awk -v v="$version" '$0 ~ "^## \\[" v "\\]" {found=1; next} found && /^## \[/ {exit} found {print}' CHANGELOG.md > release-notes.md
+          test -s release-notes.md
+          cat release-notes.md
+
+      - uses: actions/download-artifact@v8
+        with:
+          path: release_assets
+          merge-multiple: true
+
+      - name: Generate Checksums
+        shell: bash
+        run: |
+          cd release_assets
+          sha256sum * > SHA256SUMS.txt
+          echo "=== Release Assets & Checksums ==="
+          cat SHA256SUMS.txt
+
+      - name: Publish Release
+        uses: softprops/action-gh-release@v3.0.3
+        with:
+          tag_name: ${{ github.event.inputs.tag_name || github.ref_name }}
+          files: release_assets/*
+          body_path: release-notes.md

pxsteamdl-0.4.0/.github/workflows/update-ca-bundle.yml

@@ -0,0 +1,50 @@
+name: Update CA bundle
+
+# The Mozilla CA bundle that curl publishes is compiled into the library, and CMakeLists.txt pins its date and hash.
+# Once a week this looks for a newer one and opens a pull request that pins it. Binaries built from an old pin would
+# eventually stop trusting Steam's certificates.
+#
+# Needs "Allow GitHub Actions to create and approve pull requests" in the repository's Actions settings.
+on:
+  schedule:
+    - cron: "23 4 * * 1"
+  workflow_dispatch:
+
+permissions:
+  contents: write
+  pull-requests: write
+  actions: write
+
+jobs:
+  update:
+    runs-on: ubuntu-latest
+    env:
+      GH_TOKEN: ${{ github.token }}
+    steps:
+      - uses: actions/checkout@v7
+
+      - name: Look for a newer bundle
+        id: bundle
+        run: .github/scripts/update-ca-bundle.sh
+
+      - name: Open a pull request
+        if: steps.bundle.outputs.date != ''
+        env:
+          DATE: ${{ steps.bundle.outputs.date }}
+        run: |
+          branch="ci/ca-bundle-$DATE"
+          git config user.name "github-actions[bot]"
+          git config user.email "41898282+github-actions[bot]@users.noreply.github.com"
+          git switch -c "$branch"
+          git commit -am "Update the Mozilla CA bundle to $DATE"
+          git push origin "$branch"
+          gh pr create --base "${{ github.event.repository.default_branch }}" --head "$branch" \
+            --title "Update the Mozilla CA bundle to $DATE" \
+            --body "Pins the newest CA bundle published by curl (https://curl.se/docs/caextract.html), as extracted on $DATE. Opened by the *Update CA bundle* workflow."
+          # Pull requests opened with the workflow token do not start CI by themselves; a manual run does.
+          gh workflow run ci.yml --ref "$branch"
+          # An older, unmerged update is obsolete now.
+          for number in $(gh pr list --state open --search 'in:title "Update the Mozilla CA bundle"' \
+                          --json number,headRefName --jq ".[] | select(.headRefName != \"$branch\") | .number"); do
+            gh pr close "$number" --comment "Superseded by $branch." --delete-branch
+          done

pxsteamdl-0.4.0/.gitignore

@@ -0,0 +1,23 @@
+build/
+.cache/
+.vscode/
+.idea/
+compile_commands.json
+*.o
+*.obj
+*.a
+*.lib
+*.dll
+*.dylib
+*.so
+*.exe
+CMakeUserPresets.json
+.cpm-cache/
+
+# Python
+__pycache__/
+*.egg-info/
+dist/
+.venv/
+_skbuild/
+wheelhouse/