commit df42f855db1d882e75d30d8a5282a2f65959668a · pyrox.dev/nixpkgs

+2 -2

maintainers/scripts/copy-tarballs.pl

···

       176
       176
        
       

     

       177
       177
        
               if ($hash =~ /^([a-z0-9]+)-([A-Za-z0-9+\/=]+)$/) {

     

       178
       178
        
                   $algo = $1;

     

       179
       179
       -
                   $hash = `nix hash to-base16 $hash` or die;

     

       179
       179
       +
                   $hash = `nix --extra-experimental-features nix-command hash to-base16 $hash` or die;

     

       180
       180
        
                   chomp $hash;

     

       181
       181
        
               }

     

       182
       182
        
       

     
···

       184
       184
        
       

     

       185
       185
        
               # Convert non-SRI base-64 to base-16.

     

       186
       186
        
               if ($hash =~ /^[A-Za-z0-9+\/=]+$/) {

     

       187
       187
       -
                   $hash = `nix hash to-base16 --type '$algo' $hash` or die;

     

       187
       187
       +
                   $hash = `nix --extra-experimental-features nix-command hash to-base16 --type '$algo' $hash` or die;

     

       188
       188
        
                   chomp $hash;

     

       189
       189
        
               }

     

       190
       190

+2 -2

pkgs/applications/audio/reaper/updater.sh

···

       8
       8
        
       function set_hash_for_linux() {

     

       9
       9
        
         local arch=$1

     

       10
       10
        
         pkg_hash=$(nix-prefetch-url https://www.reaper.fm/files/${reaper_ver%.*}.x/reaper${reaper_ver/./}_linux_$arch.tar.xz)

     

       11
       11
       -
         pkg_hash=$(nix hash convert "sha256:$pkg_hash")

     

       11
       11
       +
         pkg_hash=$(nix --extra-experimental-features nix-command hash convert "sha256:$pkg_hash")

     

       12
       12
        
         update-source-version reaper "${reaper_ver}" "$pkg_hash" --system=$arch-linux --ignore-same-version

     

       13
       13
        
       }

     

       14
       14
        
       

     

       15
       15
        
       function set_hash_for_darwin() {

     

       16
       16
        
         local arch=$1

     

       17
       17
        
         pkg_hash=$(nix-prefetch-url https://www.reaper.fm/files/${reaper_ver%.*}.x/reaper${reaper_ver/./}_universal.dmg)

     

       18
       18
       -
         pkg_hash=$(nix hash convert "sha256:$pkg_hash")

     

       18
       18
       +
         pkg_hash=$(nix --extra-experimental-features nix-command hash convert "sha256:$pkg_hash")

     

       19
       19
        
         update-source-version reaper "${reaper_ver}" "$pkg_hash" --system=$arch-darwin --ignore-same-version

     

       20
       20
        
       }

     

       21
       21

+1 -1

pkgs/applications/blockchains/teos/update.sh

···

       23
       23
        
       git -C "$repo" checkout "tags/v${version}"

     

       24
       24
        
       

     

       25
       25
        
       rm -rf "${repo}/.git"

     

       26
       26
       -
       hashcheck=$(nix hash path "$repo")

     

       26
       26
       +
       hashcheck=$(nix --extra-experimental-features nix-command hash path "$repo")

     

       27
       27
        
       

     

       28
       28
        
       (cd "$nixpkgs" && update-source-version teos "$version" "$hashcheck" && update-source-version teos --ignore-same-version --source-key=cargoDeps)

     

       29
       29
        
       echo

+2 -2

pkgs/applications/editors/cudatext/update.sh

···

       17
       17
        
       

     

       18
       18
        
       url="https://github.com/Alexey-T/CudaText/archive/refs/tags/${version}.tar.gz"

     

       19
       19
        
       hash=$(nix-prefetch-url --quiet --unpack --type sha256 $url)

     

       20
       20
       -
       sriHash=$(nix hash to-sri --type sha256 $hash)

     

       20
       20
       +
       sriHash=$(nix --extra-experimental-features nix-command hash to-sri --type sha256 $hash)

     

       21
       21
        
       

     

       22
       22
        
       sed -i "s#version = \".*\"#version = \"$version\"#" default.nix

     

       23
       23
        
       sed -i "s#hash = \".*\"#hash = \"$sriHash\"#" default.nix

     
···

       27
       27
        
         if [ "$latest" != "$rev" ]; then

     

       28
       28
        
           url="https://github.com/${owner}/${repo}/archive/refs/tags/${latest}.tar.gz"

     

       29
       29
        
           hash=$(nix-prefetch-url --quiet --unpack --type sha256 $url)

     

       30
       30
       -
           sriHash=$(nix hash to-sri --type sha256 $hash)

     

       30
       30
       +
           sriHash=$(nix --extra-experimental-features nix-command hash to-sri --type sha256 $hash)

     

       31
       31
        
           jq ".\"${repo}\".rev = \"${latest}\" | .\"${repo}\".hash = \"${sriHash}\"" deps.json | sponge deps.json

     

       32
       32
        
         fi

     

       33
       33
        
       done <<< $(jq -r 'to_entries[]|[.key,.value.owner,.value.rev]|@tsv' deps.json)

+1 -1

pkgs/applications/editors/vscode/extensions/_maintainers/update-bin-srcs-lib.sh

···

       60
       60
        
         declare unpackedStorePath

     

       61
       61
        
         unpackedStorePath="$(nix add-to-store -n "$unpackedStoreName" "$tmpDir")"

     

       62
       62
        
         declare unpackedSha256

     

       63
       63
       -
         unpackedSha256="$(nix hash-path --base32 --type sha256 "$unpackedStorePath")"

     

       63
       63
       +
         unpackedSha256="$(nix --extra-experimental-features nix-command hash path --base32 --type sha256 "$unpackedStorePath")"

     

       64
       64
        
         1>&2 echo "unpackedStorePath='$unpackedStorePath'"

     

       65
       65
        
         1>&2 echo "unpackedSha256='$unpackedSha256'"

     

       66
       66

+1 -1

pkgs/applications/editors/vscode/extensions/ms-vscode.cpptools/update_helper.sh

···

       58
       58
        
       unzip -q -d "$tmpDir" "$cpptoolsZipStorePath"

     

       59
       59
        
       

     

       60
       60
        
       cpptoolsStorePath="$(nix add-to-store -n "$extStoreName" "$tmpDir")"

     

       61
       61
       -
       cpptoolsSha256="$(nix hash-path --base32 --type sha512 "$cpptoolsStorePath")"

     

       61
       61
       +
       cpptoolsSha256="$(nix --extra-experimental-features nix-command hash path --base32 --type sha512 "$cpptoolsStorePath")"

     

       62
       62
        
       echo "cpptoolsStorePath='$cpptoolsStorePath'"

     

       63
       63
        
       echo "cpptoolsSha256='$cpptoolsSha256'"

     

       64
       64

+1 -1

pkgs/applications/editors/vscode/update-vscode.sh

···

       18
       18
        
       

     

       19
       19
        
       systems=$(nix eval --json -f . vscode.meta.platforms | jq --raw-output '.[]')

     

       20
       20
        
       for system in $systems; do

     

       21
       21
       -
         hash=$(nix hash convert --to sri --hash-algo sha256 $(nix-prefetch-url $(nix eval --raw -f . vscode.src.url --system "$system")))

     

       21
       21
       +
         hash=$(nix --extra-experimental-features nix-command hash convert --to sri --hash-algo sha256 $(nix-prefetch-url $(nix eval --raw -f . vscode.src.url --system "$system")))

     

       22
       22
        
         update-source-version vscode $latestVersion $hash --system=$system --ignore-same-version --ignore-same-hash

     

       23
       23
        
       done

     

       24
       24

+1 -1

pkgs/applications/editors/vscode/update-vscodium.sh

···

       21
       21
        
           "aarch64-darwin darwin-arm64 zip" \

     

       22
       22
        
           "x86_64-darwin darwin-x64 zip"; do

     

       23
       23
        
           set -- $i

     

       24
       24
       -
           hash=$(nix hash convert --hash-algo sha256 --to sri $(nix-prefetch-url "https://github.com/VSCodium/vscodium/releases/download/$latestVersion/VSCodium-$2-$latestVersion.$3"))

     

       24
       24
       +
           hash=$(nix --extra-experimental-features nix-command hash convert --hash-algo sha256 --to sri $(nix-prefetch-url "https://github.com/VSCodium/vscodium/releases/download/$latestVersion/VSCodium-$2-$latestVersion.$3"))

     

       25
       25
        
           update-source-version vscodium $latestVersion $hash --system=$1 --ignore-same-version

     

       26
       26
        
       done

+1 -1

pkgs/applications/graphics/tesseract/fetch-language-hashes

···

       30
       30
        
       

     

       31
       31
        
       for lang in $langCodes; do

     

       32
       32
        
           url=https://github.com/tesseract-ocr/tessdata/raw/$tessdataRev/$lang.traineddata

     

       33
       33
       -
           hash=$(nix hash to-sri --type sha256 $(nix-prefetch-url $url 2>/dev/null))

     

       33
       33
       +
           hash=$(nix --extra-experimental-features nix-command hash to-sri --type sha256 $(nix-prefetch-url $url 2>/dev/null))

     

       34
       34
        
           echo "$lang = \"$hash\";"

     

       35
       35
        
       done

+2 -2

pkgs/applications/networking/browsers/librewolf/update.nix

···

       46
       46
        
         repoUrl=https://codeberg.org/librewolf/source.git

     

       47
       47
        
         nix-prefetch-git $repoUrl --quiet --rev $latestTag --fetch-submodules > $prefetchOut

     

       48
       48
        
         srcDir=$(jq -r .path < $prefetchOut)

     

       49
       49
       -
         srcHash=$(nix hash convert --to sri --hash-algo sha256 $(jq -r .sha256 < $prefetchOut))

     

       49
       49
       +
         srcHash=$(nix --extra-experimental-features nix-command hash convert --to sri --hash-algo sha256 $(jq -r .sha256 < $prefetchOut))

     

       50
       50
        
       

     

       51
       51
        
         ffVersion=$(<$srcDir/version)

     

       52
       52
        
         lwRelease=$(<$srcDir/release)

     
···

       68
       68
        
         curl --silent --show-error -o "$HOME"/shasums.asc "$mozillaUrl$ffVersion/SHA512SUMS.asc"

     

       69
       69
        
         gpgv --keyring="$GNUPGHOME"/pubring.kbx "$HOME"/shasums.asc "$HOME"/shasums

     

       70
       70
        
       

     

       71
       71
       -
         ffHash=$(nix hash convert --to sri --hash-algo sha512 $(grep '\.source\.tar\.xz$' "$HOME"/shasums | grep '^[^ ]*' -o))

     

       71
       71
       +
         ffHash=$(nix --extra-experimental-features nix-command hash convert --to sri --hash-algo sha512 $(grep '\.source\.tar\.xz$' "$HOME"/shasums | grep '^[^ ]*' -o))

     

       72
       72
        
         echo "ffHash=$ffHash"

     

       73
       73
        
       

     

       74
       74
        
         jq ".source.rev = \"$latestTag\"" $srcJson | sponge $srcJson

+1 -1

pkgs/applications/networking/cluster/timoni/update.sh

···

       16
       16
        
       

     

       17
       17
        
       # update hash

     

       18
       18
        
       PREV_HASH=$(nix eval --raw -f $NIXPKGS_ROOT/default.nix $ATTR.src.outputHash)

     

       19
       19
       -
       NEXT_HASH=$(nix hash to-sri --type sha256 $(nix-prefetch-url --unpack --type sha256 $(nix eval --raw -f $NIXPKGS_ROOT/default.nix $ATTR.src.url)))

     

       19
       19
       +
       NEXT_HASH=$(nix --extra-experimental-features nix-command hash to-sri --type sha256 $(nix-prefetch-url --unpack --type sha256 $(nix eval --raw -f $NIXPKGS_ROOT/default.nix $ATTR.src.url)))

     

       20
       20
        
       sed -i "s|$PREV_HASH|$NEXT_HASH|" "$FILE"

     

       21
       21
        
       

     

       22
       22
        
       # update vendor hash

+1 -1

pkgs/by-name/at/atlassian-plugin-sdk/package.nix

···

       71
       71
        
             fi

     

       72
       72
        
       

     

       73
       73
        
             DOWNLOAD_URL="${mavenGroupIdUrl}/atlassian-plugin-sdk/${version}/atlassian-plugin-sdk-$NEW_VERSION.tar.gz"

     

       74
       74
       -
             NIX_HASH=$(nix hash to-sri sha256:$(nix-prefetch-url $DOWNLOAD_URL))

     

       74
       74
       +
             NIX_HASH=$(nix --extra-experimental-features nix-command hash to-sri sha256:$(nix-prefetch-url $DOWNLOAD_URL))

     

       75
       75
        
       

     

       76
       76
        
             update-source-version "atlassian-plugin-sdk" "$NEW_VERSION" "$NIX_HASH" "$DOWNLOAD_URL"

     

       77
       77
        
           '';

+1 -1

pkgs/by-name/ba/balatro/package.nix

···

       18
       18
        
         src = requireFile {

     

       19
       19
        
           name = "Balatro-${finalAttrs.version}.exe";

     

       20
       20
        
           url = "https://store.steampowered.com/app/2379780/Balatro/";

     

       21
       21
       -
           # Use `nix hash file --sri --type sha256` to get the correct hash

     

       21
       21
       +
           # Use `nix --extra-experimental-features nix-command hash file --sri --type sha256` to get the correct hash

     

       22
       22
        
           hash = "sha256-DXX+FkrM8zEnNNSzesmHiN0V8Ljk+buLf5DE5Z3pP0c=";

     

       23
       23
        
         };

     

       24
       24

+1 -1

pkgs/by-name/be/beekeeper-studio/update.sh

···

       16
       16
        
       

     

       17
       17
        
       nix-update beekeeper-studio --version "$latestVersion" || true

     

       18
       18
        
       

     

       19
       19
       -
       hash=$(nix hash convert --to sri --hash-algo sha256 $(nix-prefetch-url "$(nix eval -f . --raw beekeeper-studio.src.url --system aarch64-linux)"))

     

       19
       19
       +
       hash=$(nix --extra-experimental-features nix-command hash convert --to sri --hash-algo sha256 $(nix-prefetch-url "$(nix eval -f . --raw beekeeper-studio.src.url --system aarch64-linux)"))

     

       20
       20
        
       update-source-version beekeeper-studio $latestVersion $hash --system=aarch64-linux --ignore-same-version

+2 -2

pkgs/by-name/bi/bilibili/update.sh

···

       14
       14
        
       arm64_hash=$(nix-prefetch-url $arm64_url)

     

       15
       15
        
       

     

       16
       16
        
       # use friendlier hashes

     

       17
       17
       -
       amd64_hash=$(nix hash convert --to sri --hash-algo sha256 "$amd64_hash")

     

       18
       18
       -
       arm64_hash=$(nix hash convert --to sri --hash-algo sha256 "$arm64_hash")

     

       17
       17
       +
       amd64_hash=$(nix --extra-experimental-features nix-command hash convert --to sri --hash-algo sha256 "$amd64_hash")

     

       18
       18
       +
       arm64_hash=$(nix --extra-experimental-features nix-command hash convert --to sri --hash-algo sha256 "$arm64_hash")

     

       19
       19
        
       

     

       20
       20
        
       cat >sources.nix <<EOF

     

       21
       21
        
       # Generated by ./update.sh - do not update manually!

+1 -1

pkgs/by-name/bl/bloomeetunes/update.sh

···

       18
       18
        
       

     

       19
       19
        
       sed -i "s/\(tag = \"v\${version}+\)[0-9]\+/\1${RunNumber}/" "$ROOT/package.nix"

     

       20
       20
        
       

     

       21
       21
       -
       hash=$(nix hash convert --hash-algo sha256 --to sri $(nix-prefetch-url --unpack "https://github.com/HemantKArya/BloomeeTunes/archive/refs/tags/${latestTag}.tar.gz"))

     

       21
       21
       +
       hash=$(nix --extra-experimental-features nix-command hash convert --hash-algo sha256 --to sri $(nix-prefetch-url --unpack "https://github.com/HemantKArya/BloomeeTunes/archive/refs/tags/${latestTag}.tar.gz"))

     

       22
       22
        
       update-source-version bloomeetunes $latestVersion $hash

     

       23
       23
        
       

     

       24
       24
        
       curl https://raw.githubusercontent.com/HemantKArya/BloomeeTunes/${latestTag}/pubspec.lock | yq . >$ROOT/pubspec.lock.json

+1 -1

pkgs/by-name/bo/boundary/update.sh

···

       15
       15
        
           local arch=$2

     

       16
       16
        
           url="https://releases.hashicorp.com/boundary/${version}/boundary_${version}_${arch}.zip"

     

       17
       17
        
           zip_hash=$(nix-prefetch-url --unpack $url)

     

       18
       18
       -
           nix hash to-sri --type sha256 "$zip_hash"

     

       18
       18
       +
           nix --extra-experimental-features nix-command hash to-sri --type sha256 "$zip_hash"

     

       19
       19
        
       }

     

       20
       20
        
       

     

       21
       21
        
       replace_sha() {

+3 -3

pkgs/by-name/bu/buck2/update.sh

···

       27
       27
        
       rm -f "$HFILE" && touch "$HFILE"

     

       28
       28
        
       

     

       29
       29
        
       PRELUDE_SHA256HASH="$(nix-prefetch-url --type sha256 "$PRELUDE_DL_URL")"

     

       30
       30
       -
       PRELUDE_SRIHASH="$(nix hash to-sri --type sha256 "$PRELUDE_SHA256HASH")"

     

       30
       30
       +
       PRELUDE_SRIHASH="$(nix --extra-experimental-features nix-command hash to-sri --type sha256 "$PRELUDE_SHA256HASH")"

     

       31
       31
        
       

     

       32
       32
        
       printf "{ \"_comment\": \"@generated by pkgs/by-name/bu/buck2/update.sh\"\n" >> "$HFILE"

     

       33
       33
        
       printf ", \"_prelude\": \"$PRELUDE_SRIHASH\"\n" >> "$HFILE"

     
···

       35
       35
        
       for arch in "${ARCHS[@]}"; do

     

       36
       36
        
           IFS=: read -r arch_name arch_target <<< "$arch"

     

       37
       37
        
           sha256hash="$(nix-prefetch-url --type sha256 "https://github.com/facebook/buck2/releases/download/${VERSION}/buck2-${arch_target}.zst")"

     

       38
       38
       -
           srihash="$(nix hash to-sri --type sha256 "$sha256hash")"

     

       38
       38
       +
           srihash="$(nix --extra-experimental-features nix-command hash to-sri --type sha256 "$sha256hash")"

     

       39
       39
        
           echo ", \"buck2-$arch_name\": \"$srihash\"" >> "$HFILE"

     

       40
       40
        
       

     

       41
       41
        
           IFS=: read -r arch_name arch_target <<< "$arch"

     

       42
       42
        
           sha256hash="$(nix-prefetch-url --type sha256 "https://github.com/facebook/buck2/releases/download/${VERSION}/rust-project-${arch_target}.zst")"

     

       43
       43
       -
           srihash="$(nix hash to-sri --type sha256 "$sha256hash")"

     

       43
       43
       +
           srihash="$(nix --extra-experimental-features nix-command hash to-sri --type sha256 "$sha256hash")"

     

       44
       44
        
           echo ", \"rust-project-$arch_name\": \"$srihash\"" >> "$HFILE"

     

       45
       45
        
       done

     

       46
       46
        
       echo "}" >> "$HFILE"

+1 -1

pkgs/by-name/bu/buckets/package.nix

···

       18
       18
        
           .${system};

     

       19
       19
        
       

     

       20
       20
        
         # Get hash in sri format

     

       21
       21
       -
         # nix-prefetch-url <url> | xargs nix hash convert --hash-algo sha256

     

       21
       21
       +
         # nix-prefetch-url <url> | xargs nix --extra-experimental-features nix-command hash convert --hash-algo sha256

     

       22
       22
        
         hash =

     

       23
       23
        
           {

     

       24
       24
        
             x86_64-linux = "sha256-DK5+VT4+OCcJ4Bbv6GGs6R332GMsD1gNEmcz0iaJb1c=";

+1 -1

pkgs/by-name/ch/chatgpt/update.sh

···

       8
       8
        
       LATEST_VERSION=$(echo "$XML_DATA" | xmllint --xpath '/rss/channel/item[1]/*[local-name()="shortVersionString"]/text()' -)

     

       9
       9
        
       DOWNLOAD_URL=$(echo "$XML_DATA" | xmllint --xpath 'string(//item[1]/enclosure/@url)' -)

     

       10
       10
        
       

     

       11
       11
       -
       HASH=$(nix-prefetch-url $DOWNLOAD_URL | xargs nix hash convert --hash-algo sha256)

     

       11
       11
       +
       HASH=$(nix-prefetch-url $DOWNLOAD_URL | xargs nix --extra-experimental-features nix-command hash convert --hash-algo sha256)

     

       12
       12
        
       

     

       13
       13
        
       SOURCE_NIX="$(dirname ${BASH_SOURCE[0]})/source.nix"

     

       14
       14

+1 -1

pkgs/by-name/cl/clojure-lsp/package.nix

···

       59
       59
        
           old_jar_hash="$(nix-instantiate --strict --json --eval -A clojure-lsp.jar.drvAttrs.outputHash | jq -r .)"

     

       60
       60
        
       

     

       61
       61
        
           curl -o clojure-lsp-standalone.jar -sL "https://github.com/clojure-lsp/clojure-lsp/releases/download/$latest_version/clojure-lsp-standalone.jar"

     

       62
       62
       -
           new_jar_hash="$(nix-hash --flat --type sha256 clojure-lsp-standalone.jar | xargs -n1 nix hash convert --hash-algo sha256)"

     

       62
       62
       +
           new_jar_hash="$(nix-hash --flat --type sha256 clojure-lsp-standalone.jar | xargs -n1 nix --extra-experimental-features nix-command hash convert --hash-algo sha256)"

     

       63
       63
        
       

     

       64
       64
        
           rm -f clojure-lsp-standalone.jar

     

       65
       65

+1 -1

pkgs/by-name/co/coder/update.sh

···

       32
       32
        
       

     

       33
       33
        
               # Fetch the new hash using nix-prefetch-url

     

       34
       34
        
               local NEW_HASH=$(nix-prefetch-url --type sha256 $URL)

     

       35
       35
       -
               local SRI_HASH=$(nix hash to-sri --type sha256 $NEW_HASH)

     

       35
       35
       +
               local SRI_HASH=$(nix --extra-experimental-features nix-command hash to-sri --type sha256 $NEW_HASH)

     

       36
       36
        
       

     

       37
       37
        
               # Update the Nix file with the new hash, using '#' as delimiter and preserving indentation

     

       38
       38
        
               sed -i "/${channel} = {/,/};/{

+1 -1

pkgs/by-name/co/confluent-cli/update.sh

···

       26
       26
        
           "x86_64-darwin darwin_amd64" \

     

       27
       27
        
           "aarch64-darwin darwin_arm64"; do

     

       28
       28
        
           set -- $i

     

       29
       29
       -
           hash=$(nix hash convert --to sri --hash-algo sha256 $(nix-prefetch-url "https://s3-us-west-2.amazonaws.com/confluent.cloud/confluent-cli/archives/$latestVersion/confluent_${latestVersion}_$2.tar.gz"))

     

       29
       29
       +
           hash=$(nix --extra-experimental-features nix-command hash convert --to sri --hash-algo sha256 $(nix-prefetch-url "https://s3-us-west-2.amazonaws.com/confluent.cloud/confluent-cli/archives/$latestVersion/confluent_${latestVersion}_$2.tar.gz"))

     

       30
       30
        
           update-source-version confluent-cli $latestVersion $hash --system=$1 --ignore-same-version

     

       31
       31
        
       done

+1 -1

pkgs/by-name/cr/crc/update.sh

···

       26
       26
        
           jq -r "map(select(.name == \"${LATEST_TAG_NAME}\")) | .[0] | .commit.sha")

     

       27
       27
        
       

     

       28
       28
        
       CRC_GIT_PREFETCH=$(nix-prefetch-url --unpack https://github.com/crc-org/crc/archive/${CRC_COMMIT}.tar.gz)

     

       29
       29
       -
       CRC_GIT_HASH=$(nix hash convert --to sri --hash-algo sha256 ${CRC_GIT_PREFETCH})

     

       29
       29
       +
       CRC_GIT_HASH=$(nix --extra-experimental-features nix-command hash convert --to sri --hash-algo sha256 ${CRC_GIT_PREFETCH})

     

       30
       30
        
       

     

       31
       31
        
       FILE_MAKEFILE=${WORKDIR}/Makefile

     

       32
       32
        
       curl --silent https://raw.githubusercontent.com/crc-org/crc/${CRC_COMMIT}/Makefile >$FILE_MAKEFILE

+1 -1

pkgs/by-name/db/dbgate/update.sh

···

       17
       17
        
           aarch64-linux \

     

       18
       18
        
           x86_64-darwin \

     

       19
       19
        
           aarch64-darwin; do

     

       20
       20
       -
           hash=$(nix hash convert --to sri --hash-algo sha256 $(nix-prefetch-url $(nix-instantiate --eval -E "with import ./. {}; dbgate.src.url" --system "$system" | tr -d '"')))

     

       20
       20
       +
           hash=$(nix --extra-experimental-features nix-command hash convert --to sri --hash-algo sha256 $(nix-prefetch-url $(nix-instantiate --eval -E "with import ./. {}; dbgate.src.url" --system "$system" | tr -d '"')))

     

       21
       21
        
           update-source-version dbgate $latestVersion $hash --system=$system --ignore-same-version

     

       22
       22
        
       done

+1 -1

pkgs/by-name/de/dependabot-cli/update.sh

···

       21
       21
        
       fi

     

       22
       22
        
       

     

       23
       23
        
       SHA256="$(nix-prefetch-url --quiet --unpack https://github.com/dependabot/cli/archive/refs/tags/v${VERSION}.tar.gz)"

     

       24
       24
       -
       HASH="$(nix hash convert --hash-algo sha256 --to sri "$SHA256")"

     

       24
       24
       +
       HASH="$(nix --extra-experimental-features nix-command hash convert --hash-algo sha256 --to sri "$SHA256")"

     

       25
       25
        
       

     

       26
       26
        
       nix-prefetch-docker --json --quiet --final-image-name dependabot-update-job-proxy --final-image-tag "nixpkgs-dependabot-cli-$VERSION" ghcr.io/github/dependabot-update-job-proxy/dependabot-update-job-proxy latest > "$temp_dir/dependabot-update-job-proxy.json"

     

       27
       27

+1 -1

pkgs/by-name/dr/draupnir/update.sh

···

       29
       29
        
       

     

       30
       30
        
       curl https://raw.githubusercontent.com/the-draupnir-project/Draupnir/v$latestVersion/yarn.lock -o yarn.lock

     

       31
       31
        
       TMP_PREFETCH_HASH=`prefetch-yarn-deps yarn.lock`

     

       32
       32
       -
       NEW_YARN_OFFLINE_HASH=`nix hash to-sri --type sha256 $TMP_PREFETCH_HASH`

     

       32
       32
       +
       NEW_YARN_OFFLINE_HASH=`nix --extra-experimental-features nix-command hash to-sri --type sha256 $TMP_PREFETCH_HASH`

     

       33
       33
        
       

     

       34
       34
        
       cd -

     

       35
       35
        
       echo "New yarn offline hash: $NEW_YARN_OFFLINE_HASH"

+1 -1

pkgs/by-name/du/duplicati/package.nix

···

       18
       18
        
           "aarch64-linux" = "linux-arm64";

     

       19
       19
        
         };

     

       20
       20
        
         _platform = _supportedPlatforms."${stdenv.hostPlatform.system}";

     

       21
       21
       -
         # nix hash convert --to sri "sha256:`nix-prefetch-url --unpack https://updates.duplicati.com/stable/duplicati-2.1.0.5_stable_2025-03-04-linux-arm64-cli.zip`"

     

       21
       21
       +
         # nix --extra-experimental-features nix-command hash convert --to sri "sha256:`nix-prefetch-url --unpack https://updates.duplicati.com/stable/duplicati-2.1.0.5_stable_2025-03-04-linux-arm64-cli.zip`"

     

       22
       22
        
         _fileHashForSystem = {

     

       23
       23
        
           "armv7l-linux" = "sha256-FQQ07M0rwvxNkHPW6iK5WBTKgFrZ4LOP4vgINfmtq4k=";

     

       24
       24
        
           "x86_64-linux" = "sha256-1QspF/A3hOtqd8bVbSqClJIHUN9gBrd18J5qvZJLkQE=";

+1 -1

pkgs/by-name/dy/dynamodb-local/package.nix

···

       74
       74
        
             fi

     

       75
       75
        
       

     

       76
       76
        
             DOWNLOAD_URL="https://d1ni2b6xgvw0s0.cloudfront.net/v2.x/dynamodb_local_$NEW_VERSION_DATE.tar.gz"

     

       77
       77
       -
             NIX_HASH=$(nix hash to-sri sha256:$(nix-prefetch-url $DOWNLOAD_URL))

     

       77
       77
       +
             NIX_HASH=$(nix --extra-experimental-features nix-command hash to-sri sha256:$(nix-prefetch-url $DOWNLOAD_URL))

     

       78
       78
        
       

     

       79
       79
        
             update-source-version "dynamodb-local" "$NEW_VERSION" "$NIX_HASH" "$DOWNLOAD_URL"

     

       80
       80
        
           '';

+1 -1

pkgs/by-name/el/electrs/update.sh

···

       32
       32
        
       git -C $repo verify-tag v${version}

     

       33
       33
        
       

     

       34
       34
        
       rm -rf $repo/.git

     

       35
       35
       -
       hash=$(nix hash path $repo)

     

       35
       35
       +
       hash=$(nix --extra-experimental-features nix-command hash path $repo)

     

       36
       36
        
       

     

       37
       37
        
       (cd "$nixpkgs" && update-source-version electrs "$version" "$hash" && update-source-version electrs --ignore-same-version --source-key=cargoDeps)

     

       38
       38
        
       echo

+1 -1

pkgs/by-name/en/envoy-bin/update.sh

···

       14
       14
        
           VER="$1"

     

       15
       15
        
           ARCH="$2"

     

       16
       16
        
           URL="https://github.com/envoyproxy/envoy/releases/download/v${VER}/envoy-${VER}-linux-${ARCH}"

     

       17
       17
       -
           nix hash convert --to sri --hash-algo sha256 "$(nix-prefetch-url --type sha256 "$URL")"

     

       17
       17
       +
           nix --extra-experimental-features nix-command hash convert --to sri --hash-algo sha256 "$(nix-prefetch-url --type sha256 "$URL")"

     

       18
       18
        
       }

     

       19
       19
        
       

     

       20
       20
        
       replace_hash() {

+1 -1

pkgs/by-name/fe/feishu/package.nix

···

       217
       217
        
               update_link=$(echo $package_info | jq -r '.data.download_link' | sed 's/lf[0-9]*-ug-sign.feishucdn.com/sf3-cn.feishucdn.com\/obj/;s/?.*$//')

     

       218
       218
        
               new_version=$(echo $package_info | jq -r '.data.version_number' | sed -n 's/.*@V//p')

     

       219
       219
        
               sha256_hash=$(nix-prefetch-url $update_link)

     

       220
       220
       -
               sri_hash=$(nix hash to-sri --type sha256 $sha256_hash)

     

       220
       220
       +
               sri_hash=$(nix --extra-experimental-features nix-command hash to-sri --type sha256 $sha256_hash)

     

       221
       221
        
               update-source-version feishu $new_version $sri_hash $update_link --system=$platform --ignore-same-version --source-key="sources.$platform"

     

       222
       222
        
             done

     

       223
       223
        
           '';

+2 -2

pkgs/by-name/fi/fishnet/update.bash

···

       14
       14
        
               grep --perl-regexp --only-matching 'EvalFileDefaultNameBig "\Knn-(\w+).nnue'

     

       15
       15
        
       )"

     

       16
       16
        
       new_nnue_big_hash="$(

     

       17
       17
       -
           nix hash to-sri --type sha256 "$(

     

       17
       17
       +
           nix --extra-experimental-features nix-command hash to-sri --type sha256 "$(

     

       18
       18
        
               nix-prefetch-url --type sha256 "https://tests.stockfishchess.org/api/nn/${new_nnue_big_file}"

     

       19
       19
        
           )"

     

       20
       20
        
       )"

     
···

       23
       23
        
               grep --perl-regexp --only-matching 'EvalFileDefaultNameSmall "\Knn-(\w+).nnue'

     

       24
       24
        
       )"

     

       25
       25
        
       new_nnue_small_hash="$(

     

       26
       26
       -
           nix hash to-sri --type sha256 "$(

     

       26
       26
       +
           nix --extra-experimental-features nix-command hash to-sri --type sha256 "$(

     

       27
       27
        
               nix-prefetch-url --type sha256 "https://tests.stockfishchess.org/api/nn/${new_nnue_small_file}"

     

       28
       28
        
           )"

     

       29
       29
        
       )"

+3 -3

pkgs/by-name/fl/fluxcd/update.sh

···

       12
       12
        
       

     

       13
       13
        
       if [ ! "$OLD_VERSION" = "$LATEST_VERSION" ]; then

     

       14
       14
        
           SRC_SHA256=$(nix-prefetch-url --quiet --unpack "https://github.com/fluxcd/flux2/archive/refs/tags/${LATEST_TAG}.tar.gz")

     

       15
       15
       -
           SRC_HASH=$(nix hash convert --hash-algo sha256 --to sri "$SRC_SHA256")

     

       15
       15
       +
           SRC_HASH=$(nix --extra-experimental-features nix-command hash convert --hash-algo sha256 --to sri "$SRC_SHA256")

     

       16
       16
        
           MANIFESTS_SHA256=$(nix-prefetch-url --quiet --unpack "https://github.com/fluxcd/flux2/releases/download/${LATEST_TAG}/manifests.tar.gz")

     

       17
       17
       -
           MANIFESTS_HASH=$(nix hash convert --hash-algo sha256 --to sri "$MANIFESTS_SHA256")

     

       17
       17
       +
           MANIFESTS_HASH=$(nix --extra-experimental-features nix-command hash convert --hash-algo sha256 --to sri "$MANIFESTS_SHA256")

     

       18
       18
        
       

     

       19
       19
        
           setKV () {

     

       20
       20
        
               sed -i "s|$1 = \".*\"|$1 = \"${2:-}\"|" "${FLUXCD_PATH}/package.nix"

     
···

       27
       27
        
       

     

       28
       28
        
           set +e

     

       29
       29
        
           VENDOR_SHA256=$(nix-build --no-out-link -A fluxcd "$NIXPKGS_PATH" 2>&1 >/dev/null | grep "got:" | cut -d':' -f2 | sed 's| ||g')

     

       30
       30
       -
           VENDOR_HASH=$(nix hash convert --hash-algo sha256 --to sri "$VENDOR_SHA256")

     

       30
       30
       +
           VENDOR_HASH=$(nix --extra-experimental-features nix-command hash convert --hash-algo sha256 --to sri "$VENDOR_SHA256")

     

       31
       31
        
           set -e

     

       32
       32
        
       

     

       33
       33
        
           if [ -n "${VENDOR_HASH:-}" ]; then

+2 -2

pkgs/by-name/ga/gauge/plugins/make-gauge-plugin.nix

···

       91
       91
        
       

     

       92
       92
        
                   echo "Fetching hash for $system"

     

       93
       93
        
                   hash=$(nix-prefetch-url --type sha256 $url --unpack)

     

       94
       94
       -
                   sriHash="$(nix hash to-sri --type sha256 $hash)"

     

       94
       94
       +
                   sriHash="$(nix --extra-experimental-features nix-command hash to-sri --type sha256 $hash)"

     

       95
       95
        
       

     

       96
       96
        
                   yq -iPoj ". + { \"$system\": { \"url\": \"$url\", \"hash\": \"$sriHash\" } }" "$tempfile"

     

       97
       97
        
               }

     
···

       101
       101
        
       

     

       102
       102
        
                   echo "Fetching hash"

     

       103
       103
        
                   hash=$(nix-prefetch-url --type sha256 $url --unpack)

     

       104
       104
       -
                   sriHash="$(nix hash to-sri --type sha256 $hash)"

     

       104
       104
       +
                   sriHash="$(nix --extra-experimental-features nix-command hash to-sri --type sha256 $hash)"

     

       105
       105
        
       

     

       106
       106
        
                   yq -iPoj ". + { \"url\": \"$url\", \"hash\": \"$sriHash\" }" "$tempfile"

     

       107
       107
        
               }

+3 -3

pkgs/by-name/go/google-chrome/update.sh

···

       41
       41
        
       

     

       42
       42
        
           local download_url="https://dl.google.com/linux/chrome/deb/pool/main/g/google-chrome-stable/google-chrome-stable_${version}-1_amd64.deb"

     

       43
       43
        
           new_hash="$(nix-prefetch-url "$download_url" 2>/dev/null)"

     

       44
       44
       -
           new_sri_hash="$(nix hash to-sri --type sha256 "$new_hash")"

     

       44
       44
       +
           new_sri_hash="$(nix --extra-experimental-features nix-command hash to-sri --type sha256 "$new_hash")"

     

       45
       45
        
       

     

       46
       46
        
           sed -i "/^  linux = stdenvNoCC.mkDerivation/,/^  });/s/version = \".*\"/version = \"$version\"/" "$DEFAULT_NIX"

     

       47
       47
        
           sed -i "/^  linux = stdenvNoCC.mkDerivation/,/^  });/s|hash = \".*\"|hash = \"$new_sri_hash\"|" "$DEFAULT_NIX"

     
···

       87
       87
        
           manifest_version="$(echo "$response" | xmllint --xpath "string(//manifest/@version)" -)"

     

       88
       88
        
       

     

       89
       89
        
           local download_url="$url$pkg"

     

       90
       90
       -
           new_hash="$(nix hash to-sri --type sha256 "$(nix-prefetch-url "$download_url" 2>/dev/null)")"

     

       91
       91
       -
           new_sri_hash="$(nix hash to-sri --type sha256 "$new_hash")"

     

       90
       90
       +
           new_hash="$(nix --extra-experimental-features nix-command hash to-sri --type sha256 "$(nix-prefetch-url "$download_url" 2>/dev/null)")"

     

       91
       91
       +
           new_sri_hash="$(nix --extra-experimental-features nix-command hash to-sri --type sha256 "$new_hash")"

     

       92
       92
        
       

     

       93
       93
        
           sed -i "/^  darwin = stdenvNoCC.mkDerivation/,/^  });/s/version = \".*\"/version = \"$manifest_version\"/" "$DEFAULT_NIX"

     

       94
       94
        
           sed -i "/^  darwin = stdenvNoCC.mkDerivation/,/^  });/s|hash = \".*\"|hash = \"$new_sri_hash\"|" "$DEFAULT_NIX"

+1 -1

pkgs/by-name/ha/hamrs-pro/update.sh

···

       19
       19
        
           aarch64-linux \

     

       20
       20
        
           x86_64-darwin \

     

       21
       21
        
           aarch64-darwin; do

     

       22
       22
       -
           hash=$(nix hash convert --to sri --hash-algo sha256 $(nix-prefetch-url $(nix-instantiate --eval -E "with import ./. {}; hamrs-pro.src.url" --system "$system" | tr -d '"')))

     

       22
       22
       +
           hash=$(nix --extra-experimental-features nix-command hash convert --to sri --hash-algo sha256 $(nix-prefetch-url $(nix-instantiate --eval -E "with import ./. {}; hamrs-pro.src.url" --system "$system" | tr -d '"')))

     

       23
       23
        
           update-source-version hamrs-pro $latestVersion $hash --system=$system --ignore-same-version

     

       24
       24
        
       done

+1 -1

pkgs/by-name/he/hey-mail/package.nix

···

       154
       154
        
           if [[ "x$UPDATE_NIX_OLD_VERSION" != "x$version" ]]; then

     

       155
       155
        
       

     

       156
       156
        
               revision=$(jq -r .revision <<<"$data")

     

       157
       157
       -
               hash=$(nix hash to-sri "sha512:$(jq -r .download_sha512 <<<"$data")")

     

       157
       157
       +
               hash=$(nix --extra-experimental-features nix-command hash to-sri "sha512:$(jq -r .download_sha512 <<<"$data")")

     

       158
       158
        
       

     

       159
       159
        
               update-source-version "$UPDATE_NIX_ATTR_PATH" "$version" "$hash"

     

       160
       160
        
               update-source-version --ignore-same-hash --version-key=rev "$UPDATE_NIX_ATTR_PATH" "$revision" "$hash"

+1 -1

pkgs/by-name/ho/hoppscotch/update.sh

···

       19
       19
        
           x86_64-linux \

     

       20
       20
        
           x86_64-darwin \

     

       21
       21
        
           aarch64-darwin; do

     

       22
       22
       -
           hash=$(nix hash convert --to sri --hash-algo sha256 $(nix-prefetch-url $(nix-instantiate --eval -E "with import $BASEDIR {}; hoppscotch.src.url" --system "$system" | tr -d '"')))

     

       22
       22
       +
           hash=$(nix --extra-experimental-features nix-command hash convert --to sri --hash-algo sha256 $(nix-prefetch-url $(nix-instantiate --eval -E "with import $BASEDIR {}; hoppscotch.src.url" --system "$system" | tr -d '"')))

     

       23
       23
        
           (cd $BASEDIR && update-source-version hoppscotch $latestVersion $hash --system=$system --ignore-same-version)

     

       24
       24
        
       done

+1 -1

pkgs/by-name/i-/i-dot-ming/package.nix

···

       35
       35
        
               curl -Lo $tmp/I.Ming.ttf https://raw.githubusercontent.com/ichitenfont/I.Ming/$version/$version/I.Ming-$version.ttf

     

       36
       36
        
               install -DT -m444 $tmp/I.Ming.ttf $tmp/share/fonts/truetype/I.Ming/I.Ming.ttf

     

       37
       37
        
               rm $tmp/I.Ming.ttf

     

       38
       38
       -
               hash=$(nix hash path --type sha256 --base32 --sri $tmp)

     

       38
       38
       +
               hash=$(nix --extra-experimental-features nix-command hash path --type sha256 --base32 --sri $tmp)

     

       39
       39
        
               sed -i -E \

     

       40
       40
        
                 -e "s/version = \"[0-9.]+\"/version = \"$version\"/" \

     

       41
       41
        
                 -e "s|hash = \".*\"|hash = \"$hash\"|" \

+1 -1

pkgs/by-name/ib/ibm-plex/update.sh

···

       37
       37
        
       

     

       38
       38
        
       for family in "${families[@]}"; do

     

       39
       39
        
           url="https://github.com/IBM/plex/releases/download/%40ibm%2Fplex-${family}%40${version}/ibm-plex-${family}.zip"

     

       40
       40
       -
           printf '  "%s" = "%s";\n' "$family" "$(nix-prefetch-url --unpack "$url" | xargs nix hash convert --hash-algo sha256)" >>"$dirname/hashes.nix"

     

       40
       40
       +
           printf '  "%s" = "%s";\n' "$family" "$(nix-prefetch-url --unpack "$url" | xargs nix --extra-experimental-features nix-command hash convert --hash-algo sha256)" >>"$dirname/hashes.nix"

     

       41
       41
        
       done

     

       42
       42
        
       

     

       43
       43
        
       printf '}\n' >> "$dirname/hashes.nix"

+1 -1

pkgs/by-name/je/jenkins/package.nix

···

       64
       64
        
       

     

       65
       65
        
             version="$(jq -r .version <<<$core_json)"

     

       66
       66
        
             sha256="$(jq -r .sha256 <<<$core_json)"

     

       67
       67
       -
             hash="$(nix hash to-sri --type sha256 "$sha256")"

     

       67
       67
       +
             hash="$(nix --extra-experimental-features nix-command hash to-sri --type sha256 "$sha256")"

     

       68
       68
        
       

     

       69
       69
        
             if [ ! "$oldVersion" = "$version" ]; then

     

       70
       70
        
               update-source-version jenkins "$version" "$hash"

+1 -1

pkgs/by-name/je/jetbrains-toolbox/update.sh

···

       28
       28
        
             unpack=""

     

       29
       29
        
           fi

     

       30
       30
        
           prefetch=$(nix-prefetch-url $unpack "$url")

     

       31
       31
       -
           hash=$(nix hash convert --hash-algo sha256 --to sri $prefetch)

     

       31
       31
       +
           hash=$(nix --extra-experimental-features nix-command hash convert --hash-algo sha256 --to sri $prefetch)

     

       32
       32
        
           update-source-version jetbrains-toolbox $latestVersion $hash --system=$system --ignore-same-version

     

       33
       33
        
       done

+1 -1

pkgs/by-name/ke/keyguard/update.sh

···

       20
       20
        
           exit 0

     

       21
       21
        
       fi

     

       22
       22
        
       

     

       23
       23
       -
       hash=$(nix hash convert --hash-algo sha256 --to sri $(nix-prefetch-url --unpack "https://github.com/AChep/keyguard-app/archive/refs/tags/${latestTag}.tar.gz"))

     

       23
       23
       +
       hash=$(nix --extra-experimental-features nix-command hash convert --hash-algo sha256 --to sri $(nix-prefetch-url --unpack "https://github.com/AChep/keyguard-app/archive/refs/tags/${latestTag}.tar.gz"))

     

       24
       24
        
       update-source-version keyguard $latestVersion $hash

     

       25
       25
        
       

     

       26
       26
        
       sed -i 's/tag = "r[0-9]\+\(\.[0-9]\+\)\?";/tag = "'"$latestTag"'";/g' "$ROOT/package.nix"

+1 -1

pkgs/by-name/li/librewolf-bin-unwrapped/update.sh

···

       19
       19
        
           "x86_64-linux linux-x86_64" \

     

       20
       20
        
           "aarch64-linux linux-arm64"; do

     

       21
       21
        
           set -- $i

     

       22
       22
       -
           hash=$(nix hash convert --to sri --hash-algo sha256 $(curl ${GITLAB_TOKEN:+-H "Private-Token: $GITLAB_TOKEN"} -sL https://gitlab.com/api/v4/projects/44042130/packages/generic/librewolf/$latestVersion/librewolf-$latestVersion-$2-package.tar.xz.sha256sum))

     

       22
       22
       +
           hash=$(nix --extra-experimental-features nix-command hash convert --to sri --hash-algo sha256 $(curl ${GITLAB_TOKEN:+-H "Private-Token: $GITLAB_TOKEN"} -sL https://gitlab.com/api/v4/projects/44042130/packages/generic/librewolf/$latestVersion/librewolf-$latestVersion-$2-package.tar.xz.sha256sum))

     

       23
       23
        
           update-source-version librewolf-bin-unwrapped $latestVersion $hash --system=$1 --ignore-same-version

     

       24
       24
        
       done

+1 -1

pkgs/by-name/lm/lmstudio/update.sh

···

       11
       11
        
         arch="${1}"

     

       12
       12
        
         url=$(echo "${packages}" | grep "${2}")

     

       13
       13
        
         version="$(echo "${url}" | cut -d/ -f6)"

     

       14
       14
       -
         hash=$(nix hash convert --hash-algo sha256 "$(nix-prefetch-url "${url}")")

     

       14
       14
       +
         hash=$(nix --extra-experimental-features nix-command hash convert --hash-algo sha256 "$(nix-prefetch-url "${url}")")

     

       15
       15
        
       

     

       16
       16
        
         update-source-version lmstudio "${version}" "${hash}" --system="${arch}" --version-key="version_${arch}" \

     

       17
       17
        
           2> >(tee /dev/stderr) | grep -q "nothing to do" && exit

+2 -2

pkgs/by-name/lo/localsend/update.sh

···

       17
       17
        
       sed -i "s/version = \".*\"/version = \"${latestVersion}\"/" "$ROOT/package.nix"

     

       18
       18
        
       

     

       19
       19
        
       DARWIN_x64_URL="https://github.com/localsend/localsend/releases/download/v${latestVersion}/LocalSend-${latestVersion}.dmg"

     

       20
       20
       -
       DARWIN_X64_SHA=$(nix hash to-sri --type sha256 $(nix-prefetch-url ${DARWIN_x64_URL}))

     

       20
       20
       +
       DARWIN_X64_SHA=$(nix --extra-experimental-features nix-command hash to-sri --type sha256 $(nix-prefetch-url ${DARWIN_x64_URL}))

     

       21
       21
        
       sed -i "/darwin/,/hash/{s|hash = \".*\"|hash = \"${DARWIN_X64_SHA}\"|}" "$ROOT/package.nix"

     

       22
       22
        
       

     

       23
       23
        
       GIT_SRC_URL="https://github.com/localsend/localsend/archive/refs/tags/v${latestVersion}.tar.gz"

     

       24
       24
       -
       GIT_SRC_SHA=$(nix hash to-sri --type sha256 $(nix-prefetch-url --unpack ${GIT_SRC_URL}))

     

       24
       24
       +
       GIT_SRC_SHA=$(nix --extra-experimental-features nix-command hash to-sri --type sha256 $(nix-prefetch-url --unpack ${GIT_SRC_URL}))

     

       25
       25
        
       sed -i "/linux/,/hash/{s|hash = \".*\"|hash = \"${GIT_SRC_SHA}\"|}" "$ROOT/package.nix"

     

       26
       26
        
       curl https://raw.githubusercontent.com/localsend/localsend/v${latestVersion}/app/pubspec.lock | yq . > $ROOT/pubspec.lock.json

+1 -1

pkgs/by-name/mi/mihomo-party/update.sh

···

       18
       18
        
           "aarch64-linux arm64"; do

     

       19
       19
        
           set -- $i

     

       20
       20
        
           prefetch=$(nix-prefetch-url "https://github.com/mihomo-party-org/mihomo-party/releases/download/v$latestVersion/mihomo-party-linux-$latestVersion-$2.deb")

     

       21
       21
       -
           hash=$(nix hash convert --hash-algo sha256 --to sri $prefetch)

     

       21
       21
       +
           hash=$(nix --extra-experimental-features nix-command hash convert --hash-algo sha256 --to sri $prefetch)

     

       22
       22
        
           update-source-version mihomo-party $latestVersion $hash --system=$1 --ignore-same-version

     

       23
       23
        
       done

+1 -1

pkgs/by-name/mu/mullvad-browser/update.nix

···

       67
       67
        
         for platform in ${lib.escapeShellArgs meta.platforms}; do

     

       68
       68
        
           arch="''${platforms[$platform]}"

     

       69
       69
        
           sha256=$(grep "${name}-$arch-$version.tar.xz" "$HOME/shasums" | head -1 | cut -d" " -f1)

     

       70
       70
       -
           hash=$(nix hash to-sri --type sha256 "$sha256")

     

       70
       70
       +
           hash=$(nix --extra-experimental-features nix-command hash to-sri --type sha256 "$sha256")

     

       71
       71
        
       

     

       72
       72
        
           update-source-version "${pname}" "$version" "$hash" --ignore-same-version --source-key="sources.$platform"

     

       73
       73
        
         done

+1 -1

pkgs/by-name/nb/nbxplorer/util/update-common.sh

···

       58
       58
        
       echo "Verifying commit"

     

       59
       59
        
       git -C $repo verify-commit HEAD

     

       60
       60
        
       rm -rf $repo/.git

     

       61
       61
       -
       newHash=$(nix hash-path $repo)

     

       61
       61
       +
       newHash=$(nix --extra-experimental-features nix-command hash path $repo)

     

       62
       62
        
       rm -rf $tmpdir

     

       63
       63
        
       echo

     

       64
       64

+1 -1

pkgs/by-name/om/ombi/update.sh

···

       15
       15
        
       

     

       16
       16
        
           url="https://github.com/Ombi-app/Ombi/releases/download/v$version/$os-$arch.tar.gz"

     

       17
       17
        
           hash=$(nix-prefetch-url --type sha256 $url)

     

       18
       18
       -
           sriHash="$(nix hash to-sri --type sha256 $hash)"

     

       18
       18
       +
           sriHash="$(nix --extra-experimental-features nix-command hash to-sri --type sha256 $hash)"

     

       19
       19
        
       

     

       20
       20
        
           sed -i "s|$hashKey = \"[a-zA-Z0-9\/+-=]*\";|$hashKey = \"$sriHash\";|g" "$dirname/default.nix"

     

       21
       21
        
       }

+2 -2

pkgs/by-name/pd/pdfium-binaries/update.sh

···

       21
       21
        
           aarch64-linux \

     

       22
       22
        
           x86_64-darwin \

     

       23
       23
        
           aarch64-darwin; do

     

       24
       24
       -
           hash=$(nix hash convert --to sri --hash-algo sha256 $(nix-prefetch-url --unpack $(nix-instantiate --eval -E "with import ./. {}; pdfium-binaries.src.url" --system "$system" | tr -d '"')))

     

       24
       24
       +
           hash=$(nix --extra-experimental-features nix-command hash convert --to sri --hash-algo sha256 $(nix-prefetch-url --unpack $(nix-instantiate --eval -E "with import ./. {}; pdfium-binaries.src.url" --system "$system" | tr -d '"')))

     

       25
       25
        
           update-source-version pdfium-binaries $latestVersion $hash --system=$system --ignore-same-version

     

       26
       26
        
       done

     

       27
       27
        
       

     
···

       30
       30
        
           aarch64-linux \

     

       31
       31
        
           x86_64-darwin \

     

       32
       32
        
           aarch64-darwin; do

     

       33
       33
       -
           hash=$(nix hash convert --to sri --hash-algo sha256 $(nix-prefetch-url --unpack $(nix-instantiate --eval -E "with import ./. {}; pdfium-binaries-v8.src.url" --system "$system" | tr -d '"')))

     

       33
       33
       +
           hash=$(nix --extra-experimental-features nix-command hash convert --to sri --hash-algo sha256 $(nix-prefetch-url --unpack $(nix-instantiate --eval -E "with import ./. {}; pdfium-binaries-v8.src.url" --system "$system" | tr -d '"')))

     

       34
       34
        
           update-source-version pdfium-binaries-v8 $latestVersion $hash --system=$system --ignore-same-version

     

       35
       35
        
       done

+1 -1

pkgs/by-name/pe/perses/update.sh

···

       23
       23
        
           echo "    url = \"${url}\";"

     

       24
       24
        
       

     

       25
       25
        
           hash="$(nix-prefetch-url "${url}" --name "${UPDATE_NIX_PNAME}-${name,,}-${version}.tar.gz")"

     

       26
       26
       -
           hash="$(nix hash convert --hash-algo sha256 "${hash}")"

     

       26
       26
       +
           hash="$(nix --extra-experimental-features nix-command hash convert --hash-algo sha256 "${hash}")"

     

       27
       27
        
       

     

       28
       28
        
           echo "    hash = \"${hash}\";"

     

       29
       29

+1 -1

pkgs/by-name/ph/phoenixd/update.sh

···

       19
       19
        
           aarch64-linux \

     

       20
       20
        
           x86_64-darwin \

     

       21
       21
        
           aarch64-darwin; do

     

       22
       22
       -
           hash=$(nix hash convert --to sri --hash-algo sha256 $(nix-prefetch-url $(nix-instantiate --eval -E "with import ./. {}; phoenixd.src.url" --system "$system" | tr -d '"')))

     

       22
       22
       +
           hash=$(nix --extra-experimental-features nix-command hash convert --to sri --hash-algo sha256 $(nix-prefetch-url $(nix-instantiate --eval -E "with import ./. {}; phoenixd.src.url" --system "$system" | tr -d '"')))

     

       23
       23
        
           update-source-version phoenixd $latestVersion $hash --system=$system --ignore-same-version

     

       24
       24
        
       done

+1 -1

pkgs/by-name/pi/pilipalax/update.sh

···

       18
       18
        
       

     

       19
       19
        
       sed -i "s/\(tag = \"\${version}+\)[0-9]\+/\1${RunNumber}/" "$ROOT/package.nix"

     

       20
       20
        
       

     

       21
       21
       -
       hash=$(nix hash convert --hash-algo sha256 --to sri $(nix-prefetch-url --unpack "https://github.com/orz12/PiliPalaX/archive/refs/tags/${latestTag}.tar.gz"))

     

       21
       21
       +
       hash=$(nix --extra-experimental-features nix-command hash convert --hash-algo sha256 --to sri $(nix-prefetch-url --unpack "https://github.com/orz12/PiliPalaX/archive/refs/tags/${latestTag}.tar.gz"))

     

       22
       22
        
       update-source-version pilipalax $latestVersion $hash

     

       23
       23
        
       

     

       24
       24
        
       curl https://raw.githubusercontent.com/orz12/PiliPalaX/${latestTag}/pubspec.lock | yq . >$ROOT/pubspec.lock.json

+3 -3

pkgs/by-name/pl/platformsh/update.sh

···

       10
       10
        
       linux_arm64_url=https://github.com/platformsh/cli/releases/download/$version/platform_${version}_linux_arm64.tar.gz

     

       11
       11
        
       linux_amd64_url=https://github.com/platformsh/cli/releases/download/$version/platform_${version}_linux_amd64.tar.gz

     

       12
       12
        
       darwin_all_url=https://github.com/platformsh/cli/releases/download/$version/platform_${version}_darwin_all.tar.gz

     

       13
       13
       -
       linux_arm64_hash=$(nix hash to-sri --type sha256 $(nix-prefetch-url --type sha256 "$linux_arm64_url"))

     

       14
       14
       -
       linux_amd64_hash=$(nix hash to-sri --type sha256 $(nix-prefetch-url --type sha256 "$linux_amd64_url"))

     

       15
       15
       -
       darwin_all_hash=$(nix hash to-sri --type sha256 $(nix-prefetch-url --type sha256 "$darwin_all_url"))

     

       13
       13
       +
       linux_arm64_hash=$(nix --extra-experimental-features nix-command hash to-sri --type sha256 $(nix-prefetch-url --type sha256 "$linux_arm64_url"))

     

       14
       14
       +
       linux_amd64_hash=$(nix --extra-experimental-features nix-command hash to-sri --type sha256 $(nix-prefetch-url --type sha256 "$linux_amd64_url"))

     

       15
       15
       +
       darwin_all_hash=$(nix --extra-experimental-features nix-command hash to-sri --type sha256 $(nix-prefetch-url --type sha256 "$darwin_all_url"))

     

       16
       16
        
       jq -n \

     

       17
       17
        
           --arg version "$version" \

     

       18
       18
        
           --arg darwin_all_hash "$darwin_all_hash" \

+1 -1

pkgs/by-name/pr/protoc-gen-grpc-java/update.sh

···

       27
       27
        
       echo '{' >"${HASHES_FILE}"

     

       28
       28
        
       for arch in "${ARCHS[@]}"; do

     

       29
       29
        
         url="https://repo1.maven.org/maven2/io/grpc/protoc-gen-grpc-java/${version}/protoc-gen-grpc-java-${version}-${arch}.exe"

     

       30
       30
       -
         hash=$(nix hash convert --hash-algo sha256 --to sri "$(nix-prefetch-url "${url}")")

     

       30
       30
       +
         hash=$(nix --extra-experimental-features nix-command hash convert --hash-algo sha256 --to sri "$(nix-prefetch-url "${url}")")

     

       31
       31
        
         echo "  ${arch} = \"${hash}\";" >>"${HASHES_FILE}"

     

       32
       32
        
       done

     

       33
       33
        
       echo '}' >>"${HASHES_FILE}"

+3 -3

pkgs/by-name/qq/qq/update.sh

···

       16
       16
        
       darwin_hash=$(nix-prefetch-url $darwin_url)

     

       17
       17
        
       

     

       18
       18
        
       # use friendlier hashes

     

       19
       19
       -
       darwin_hash=$(nix hash convert --to sri --hash-algo sha256 "$darwin_hash")

     

       19
       19
       +
       darwin_hash=$(nix --extra-experimental-features nix-command hash convert --to sri --hash-algo sha256 "$darwin_hash")

     

       20
       20
        
       

     

       21
       21
        
       # linux

     

       22
       22
        
       

     
···

       31
       31
        
       linux_x86_64_hash=$(nix-prefetch-url $linux_x86_64_url)

     

       32
       32
        
       

     

       33
       33
        
       # use friendlier hashes

     

       34
       34
       -
       linux_aarch64_hash=$(nix hash convert --to sri --hash-algo sha256 "$linux_aarch64_hash")

     

       35
       35
       -
       linux_x86_64_hash=$(nix hash convert --to sri --hash-algo sha256 "$linux_x86_64_hash")

     

       34
       34
       +
       linux_aarch64_hash=$(nix --extra-experimental-features nix-command hash convert --to sri --hash-algo sha256 "$linux_aarch64_hash")

     

       35
       35
       +
       linux_x86_64_hash=$(nix --extra-experimental-features nix-command hash convert --to sri --hash-algo sha256 "$linux_x86_64_hash")

     

       36
       36
        
       

     

       37
       37
        
       cat >sources.nix <<EOF

     

       38
       38
        
       # Generated by ./update.sh - do not update manually!

+1 -1

pkgs/by-name/re/readarr/update.sh

···

       15
       15
        
       

     

       16
       16
        
           url="https://github.com/Readarr/Readarr/releases/download/v$version/Readarr.develop.$version.$os-core-$arch.tar.gz"

     

       17
       17
        
           hash=$(nix-prefetch-url --type sha256 $url)

     

       18
       18
       -
           sriHash="$(nix hash to-sri --type sha256 $hash)"

     

       18
       18
       +
           sriHash="$(nix --extra-experimental-features nix-command hash to-sri --type sha256 $hash)"

     

       19
       19
        
       

     

       20
       20
        
           sed -i "s|$hashKey = \"[a-zA-Z0-9\/+-=]*\";|$hashKey = \"$sriHash\";|g" "$dirname/package.nix"

     

       21
       21
        
       }

+1 -1

pkgs/by-name/rn/rnnoise/package.nix

···

       65
       65
        
           #!nix-shell -i bash -p curl jq common-updater-scripts nix nix-prefetch findutils moreutils

     

       66
       66
        
       

     

       67
       67
        
           prefetch-sri() {

     

       68
       68
       -
               nix-prefetch-url "$1" | xargs nix hash to-sri --type sha256

     

       68
       68
       +
               nix-prefetch-url "$1" | xargs nix --extra-experimental-features nix-command hash to-sri --type sha256

     

       69
       69
        
           }

     

       70
       70
        
       

     

       71
       71
        
           res="$(curl ''${GITHUB_TOKEN:+-u ":$GITHUB_TOKEN"} \

+1 -1

pkgs/by-name/ru/rundeck/package.nix

···

       55
       55
        
       

     

       56
       56
        
           if [[ "x$UPDATE_NIX_OLD_VERSION" != "x$full_version" ]]; then

     

       57
       57
        
             download_url="https://packagecloud.io/pagerduty/rundeck/packages/java/org.rundeck/rundeck-$full_version.war/artifacts/rundeck-$full_version.war/download?distro_version_id=167"

     

       58
       58
       -
             hash=$(curl -L "$download_url" | nix-hash --flat --type sha256 --base32 - | nix hash to-sri --type sha256)

     

       58
       58
       +
             hash=$(curl -L "$download_url" | nix-hash --flat --type sha256 --base32 - | nix --extra-experimental-features nix-command hash to-sri --type sha256)

     

       59
       59
        
             update-source-version "$UPDATE_NIX_ATTR_PATH" "$full_version" "$hash"

     

       60
       60
        
           fi

     

       61
       61
        
         '';

+1 -1

pkgs/by-name/si/signal-desktop-bin/update.sh

···

       17
       17
        
       latestVersionAarch64=$(jq -r '.source_package.version' <<< $latestBuildInfoAarch64)

     

       18
       18
        
       latestPrettyVersionAarch64="${latestVersionAarch64%-*}"

     

       19
       19
        
       

     

       20
       20
       -
       darwinHash="$(nix hash convert --hash-algo sha256 --to sri "$(nix-prefetch-url "https://updates.signal.org/desktop/signal-desktop-mac-universal-${latestVersion}.dmg")")"

     

       20
       20
       +
       darwinHash="$(nix --extra-experimental-features nix-command hash convert --hash-algo sha256 --to sri "$(nix-prefetch-url "https://updates.signal.org/desktop/signal-desktop-mac-universal-${latestVersion}.dmg")")"

     

       21
       21
        
       

     

       22
       22
        
       echo "Updating signal-desktop for x86_64-linux"

     

       23
       23
        
       update-source-version signal-desktop-bin "$latestVersion" \

+1 -1

pkgs/by-name/sp/sparkle/update.sh

···

       13
       13
        
       fi

     

       14
       14
        
       

     

       15
       15
        
       nix-update sparkle --version $latestVersion --system x86_64-linux

     

       16
       16
       -
       hash=$(nix hash convert --to sri --hash-algo sha256 $(nix-prefetch-url $(nix-instantiate --eval -E "with import ./. {}; sparkle.src.url" --system aarch64-linux | tr -d '"')))

     

       16
       16
       +
       hash=$(nix --extra-experimental-features nix-command hash convert --to sri --hash-algo sha256 $(nix-prefetch-url $(nix-instantiate --eval -E "with import ./. {}; sparkle.src.url" --system aarch64-linux | tr -d '"')))

     

       17
       17
        
       update-source-version sparkle $latestVersion $hash --system=aarch64-linux --ignore-same-version

+1 -1

pkgs/by-name/st/standardnotes/update.nix

···

       61
       61
        
           upstreamPlatform="$2"

     

       62
       62
        
           url=$(getDownloadUrl "$upstreamPlatform")

     

       63
       63
        
           hash=$(nix-prefetch-url "$url" --type sha512)

     

       64
       64
       -
           sriHash=$(nix hash to-sri --type sha512 $hash)

     

       64
       64
       +
           sriHash=$(nix --extra-experimental-features nix-command hash to-sri --type sha512 $hash)

     

       65
       65
        
           setJsonKey .deb[\""$nixPlatform"\"].url "$url"

     

       66
       66
        
           setJsonKey .deb[\""$nixPlatform"\"].hash "$sriHash"

     

       67
       67
        
         }

+2 -2

pkgs/by-name/st/stockfish/update.bash

···

       2
       2
        
       new_nnue_big_file="$(grep --perl-regexp --only-matching 'EvalFileDefaultNameBig "\Knn-(\w+).nnue' "$new_src/src/evaluate.h")"

     

       3
       3
        
       new_nnue_small_file="$(grep --perl-regexp --only-matching 'EvalFileDefaultNameSmall "\Knn-(\w+).nnue' "$new_src/src/evaluate.h")"

     

       4
       4
        
       new_nnue_big_hash="$(

     

       5
       5
       -
           nix hash convert --hash-algo sha256 "$(

     

       5
       5
       +
           nix --extra-experimental-features nix-command hash convert --hash-algo sha256 "$(

     

       6
       6
        
               nix-prefetch-url --type sha256 "https://tests.stockfishchess.org/api/nn/$new_nnue_big_file"

     

       7
       7
        
           )"

     

       8
       8
        
       )"

     

       9
       9
        
       new_nnue_small_hash="$(

     

       10
       10
       -
           nix hash convert --hash-algo sha256 "$(

     

       10
       10
       +
           nix --extra-experimental-features nix-command hash convert --hash-algo sha256 "$(

     

       11
       11
        
               nix-prefetch-url --type sha256 "https://tests.stockfishchess.org/api/nn/$new_nnue_small_file"

     

       12
       12
        
           )"

     

       13
       13
        
       )"

+1 -1

pkgs/by-name/su/sudachidict/update.sh

···

       17
       17
        
         URL="https://github.com/$ORG/$REPO/releases/download/v$VERSION/sudachi-dictionary-$VERSION-$TYPE.zip"

     

       18
       18
        
       

     

       19
       19
        
         PLAIN_HASH=$(nix-prefetch-url --type sha256 "$URL" --unpack)

     

       20
       20
       -
         HASH=$(nix hash convert --hash-algo sha256 --to sri "$PLAIN_HASH")

     

       20
       20
       +
         HASH=$(nix --extra-experimental-features nix-command hash convert --hash-algo sha256 --to sri "$PLAIN_HASH")

     

       21
       21
        
       

     

       22
       22
        
         sed -i -E "/(${TYPE} = fetchzip \{|^ *url = .*${TYPE}\.zip\";\$)/,/^ *hash = / s|hash = \"[^\"]*\"|hash = \"$HASH\"|" package.nix

     

       23
       23
        
       done

+1 -1

pkgs/by-name/ta/tailwindcss_3/update.sh

···

       19
       19
        
           echo "Updating tailwindcss_3 for $NIXPLAT"

     

       20
       20
        
       

     

       21
       21
        
           URL="https://github.com/tailwindlabs/tailwindcss/releases/download/v${LATEST_VERSION}/tailwindcss-${TAILWINDPLAT}"

     

       22
       22
       -
           HASH=$(nix hash to-sri --type sha256 "$(nix-prefetch-url --type sha256 "$URL")")

     

       22
       22
       +
           HASH=$(nix --extra-experimental-features nix-command hash to-sri --type sha256 "$(nix-prefetch-url --type sha256 "$URL")")

     

       23
       23
        
       

     

       24
       24
        
           sed -i "s,$NIXPLAT = \"sha256.*\",$NIXPLAT = \"${HASH}\"," "$ROOT/package.nix"

     

       25
       25
        
       }

+1 -1

pkgs/by-name/ta/tandoor-recipes/update.sh

···

       34
       34
        
       popd

     

       35
       35
        
       

     

       36
       36
        
       # Use friendlier hashes

     

       37
       37
       -
       yarn_hash=$(nix hash to-sri --type sha256 "$yarn_hash")

     

       37
       37
       +
       yarn_hash=$(nix --extra-experimental-features nix-command hash to-sri --type sha256 "$yarn_hash")

     

       38
       38
        
       

     

       39
       39
        
       common="./pkgs/applications/misc/tandoor-recipes/common.nix"

     

       40
       40
        
       sed -i -E -e "s#version = \".*\"#version = \"$version\"#" $common

+1 -1

pkgs/by-name/te/termius/package.nix

···

       99
       99
        
           if [[ "x$UPDATE_NIX_OLD_VERSION" != "x$version" ]]; then

     

       100
       100
        
       

     

       101
       101
        
               revision=$(jq -r .revision <<<"$data")

     

       102
       102
       -
               hash=$(nix hash to-sri "sha512:$(jq -r .download_sha512 <<<"$data")")

     

       102
       102
       +
               hash=$(nix --extra-experimental-features nix-command hash to-sri "sha512:$(jq -r .download_sha512 <<<"$data")")

     

       103
       103
        
       

     

       104
       104
        
               update-source-version "$UPDATE_NIX_ATTR_PATH" "$version" "$hash"

     

       105
       105
        
               update-source-version --ignore-same-hash --version-key=revision "$UPDATE_NIX_ATTR_PATH" "$revision" "$hash"

+1 -1

pkgs/by-name/th/the-unarchiver/update/update.mjs

···

       84
       84
        
           process.exit(1);

     

       85
       85
        
         }

     

       86
       86
        
         const hash = child_process

     

       87
       87
       -
           .execSync(`nix hash convert --hash-algo sha256 --to sri ${prefetchHash}`)

     

       87
       87
       +
           .execSync(`nix --extra-experimental-features nix-command hash convert --hash-algo sha256 --to sri ${prefetchHash}`)

     

       88
       88
        
           .toString()

     

       89
       89
        
           .trim();

     

       90
       90
        
         /** @type {Info} */

+1 -1

pkgs/by-name/to/tor-browser/update.nix

···

       67
       67
        
         for platform in ${lib.escapeShellArgs meta.platforms}; do

     

       68
       68
        
           arch="''${platforms[$platform]}"

     

       69
       69
        
           sha256=$(grep "${name}-$arch-$version.tar.xz" "$HOME/shasums" | head -1 | cut -d" " -f1)

     

       70
       70
       -
           hash=$(nix hash to-sri --type sha256 "$sha256")

     

       70
       70
       +
           hash=$(nix --extra-experimental-features nix-command hash to-sri --type sha256 "$sha256")

     

       71
       71
        
       

     

       72
       72
        
           update-source-version "${pname}" "$version" "$hash" --ignore-same-version --source-key="sources.$platform"

     

       73
       73
        
         done

+1 -1

pkgs/by-name/tr/tradingview/update.sh

···

       15
       15
        
       # "revision" is the actual version identifier; "version" is for human consumption.

     

       16
       16
        
       revision="${snap_info[0]}"

     

       17
       17
        
       sha512="${snap_info[1]}"

     

       18
       18
       -
       sri=$(nix hash to-sri --type "sha512" $sha512)

     

       18
       18
       +
       sri=$(nix --extra-experimental-features nix-command hash to-sri --type "sha512" $sha512)

     

       19
       19
        
       upstream_version="${snap_info[2]}"

     

       20
       20
        
       last_updated="${snap_info[3]}"

     

       21
       21

+1 -1

pkgs/by-name/ty/typesense/update.sh

···

       32
       32
        
           arch="${platforms[$platform]}"

     

       33
       33
        
           url="https://dl.typesense.org/releases/${version}/typesense-server-${version}-${arch}.tar.gz"

     

       34
       34
        
           sha256hash="$(nix-prefetch-url --type sha256 "$url")"

     

       35
       35
       -
           hash="$(nix hash to-sri --type sha256 "$sha256hash")"

     

       35
       35
       +
           hash="$(nix --extra-experimental-features nix-command hash to-sri --type sha256 "$sha256hash")"

     

       36
       36
        
           echo "$(jq --arg arch "$arch" \

     

       37
       37
        
             --arg platform "$platform" \

     

       38
       38
        
             --arg hash "$hash" \

+3 -3

pkgs/by-name/up/upsun/update.sh

···

       10
       10
        
       linux_arm64_url=https://github.com/platformsh/cli/releases/download/$version/upsun_${version}_linux_arm64.tar.gz

     

       11
       11
        
       linux_amd64_url=https://github.com/platformsh/cli/releases/download/$version/upsun_${version}_linux_amd64.tar.gz

     

       12
       12
        
       darwin_all_url=https://github.com/platformsh/cli/releases/download/$version/upsun_${version}_darwin_all.tar.gz

     

       13
       13
       -
       linux_arm64_hash=$(nix hash to-sri --type sha256 $(nix-prefetch-url --type sha256 "$linux_arm64_url"))

     

       14
       14
       -
       linux_amd64_hash=$(nix hash to-sri --type sha256 $(nix-prefetch-url --type sha256 "$linux_amd64_url"))

     

       15
       15
       -
       darwin_all_hash=$(nix hash to-sri --type sha256 $(nix-prefetch-url --type sha256 "$darwin_all_url"))

     

       13
       13
       +
       linux_arm64_hash=$(nix --extra-experimental-features nix-command hash to-sri --type sha256 $(nix-prefetch-url --type sha256 "$linux_arm64_url"))

     

       14
       14
       +
       linux_amd64_hash=$(nix --extra-experimental-features nix-command hash to-sri --type sha256 $(nix-prefetch-url --type sha256 "$linux_amd64_url"))

     

       15
       15
       +
       darwin_all_hash=$(nix --extra-experimental-features nix-command hash to-sri --type sha256 $(nix-prefetch-url --type sha256 "$darwin_all_url"))

     

       16
       16
        
       jq -n \

     

       17
       17
        
           --arg version "$version" \

     

       18
       18
        
           --arg darwin_all_hash "$darwin_all_hash" \

+1 -1

pkgs/by-name/va/vault-bin/update-bin.sh

···

       15
       15
        
           local arch=$2

     

       16
       16
        
           url="https://releases.hashicorp.com/vault/${version}/vault_${version}_${arch}.zip"

     

       17
       17
        
           zip_hash=$(nix-prefetch-url --unpack $url)

     

       18
       18
       -
           nix hash to-sri --type sha256 "$zip_hash"

     

       18
       18
       +
           nix --extra-experimental-features nix-command hash to-sri --type sha256 "$zip_hash"

     

       19
       19
        
       }

     

       20
       20
        
       

     

       21
       21
        
       replace_sha() {

+1 -1

pkgs/by-name/vi/vivaldi/update-vivaldi.sh

···

       7
       7
        
       

     

       8
       8
        
       update_hash() {

     

       9
       9
        
           url="https://downloads.vivaldi.com/stable/vivaldi-stable_$version-1_$2.deb"

     

       10
       10
       -
           hash=$(nix hash to-sri --type sha256 $(nix-prefetch-url --type sha256 "$url"))

     

       10
       10
       +
           hash=$(nix --extra-experimental-features nix-command hash to-sri --type sha256 $(nix-prefetch-url --type sha256 "$url"))

     

       11
       11
        
           update-source-version vivaldi "$version" "$hash" --system=$1 --ignore-same-version

     

       12
       12
        
       }

     

       13
       13

+2 -2

pkgs/by-name/wa/waveterm/update.sh

···

       20
       20
        
           "aarch64-linux arm64"; do

     

       21
       21
        
           set -- $i

     

       22
       22
        
           prefetch=$(nix-prefetch-url "https://github.com/wavetermdev/waveterm/releases/download/v$latestVersion/waveterm-linux-$2-$latestVersion.deb")

     

       23
       23
       -
           hash=$(nix hash convert --hash-algo sha256 --to sri $prefetch)

     

       23
       23
       +
           hash=$(nix --extra-experimental-features nix-command hash convert --hash-algo sha256 --to sri $prefetch)

     

       24
       24
        
           update-source-version waveterm $latestVersion $hash --system=$1 --ignore-same-version

     

       25
       25
        
       done

     

       26
       26
        
       

     
···

       29
       29
        
           "aarch64-darwin arm64"; do

     

       30
       30
        
           set -- $i

     

       31
       31
        
           prefetch=$(nix-prefetch-url "https://github.com/wavetermdev/waveterm/releases/download/v$latestVersion/Wave-darwin-$2-$latestVersion.zip")

     

       32
       32
       -
           hash=$(nix hash convert --hash-algo sha256 --to sri $prefetch)

     

       32
       32
       +
           hash=$(nix --extra-experimental-features nix-command hash convert --hash-algo sha256 --to sri $prefetch)

     

       33
       33
        
           update-source-version waveterm $latestVersion $hash --system=$1 --ignore-same-version

     

       34
       34
        
       done

+1 -1

pkgs/by-name/we/wechat-uos/update.sh

···

       40
       40
        
           }

     

       41
       41
        
           ')

     

       42
       42
        
           url+=("https://pro-store-packages.uniontech.com/appstore/pool/appstore/c/com.tencent.wechat/com.tencent.wechat_"$version"_"$i".deb")

     

       43
       43
       -
           hash+=("$(nix hash to-sri --type sha256 $sha256sum)")

     

       43
       43
       +
           hash+=("$(nix --extra-experimental-features nix-command hash to-sri --type sha256 $sha256sum)")

     

       44
       44
        
       done

     

       45
       45
        
       

     

       46
       46
        
       cat >sources.nix <<EOF

+1 -1

pkgs/by-name/wh/whisparr/update.sh

···

       24
       24
        
         echo "Updating the hash for the \`${system}\` system..."

     

       25
       25
        
         url="https://whisparr.servarr.com/v1/update/nightly/updatefile?runtime=netcore&version=${version}&arch=${arch}&os=${os}"

     

       26
       26
        
         hash=$(nix-prefetch-url --type sha256 --name "whisparr-$system-$version.tar.gz" "$url")

     

       27
       27
       -
         sriHash="$(nix hash to-sri --type sha256 "$hash")"

     

       27
       27
       +
         sriHash="$(nix --extra-experimental-features nix-command hash to-sri --type sha256 "$hash")"

     

       28
       28
        
       

     

       29
       29
        
         sed -i "s#$hashKey = \"[a-zA-Z0-9\/+-=]*\"#$hashKey = \"$sriHash\"#" "$dirname/package.nix"

     

       30
       30
        
       }

+1 -1

pkgs/by-name/xu/xunlei-uos/update.sh

···

       40
       40
        
           }

     

       41
       41
        
           ')

     

       42
       42
        
           url+=("https://pro-store-packages.uniontech.com/appstore/pool/appstore/c/com.xunlei.download/com.xunlei.download_"$version"_"$i".deb")

     

       43
       43
       -
           hash+=("$(nix hash convert --to sri --hash-algo sha256 $sha256sum)")

     

       43
       43
       +
           hash+=("$(nix --extra-experimental-features nix-command hash convert --to sri --hash-algo sha256 $sha256sum)")

     

       44
       44
        
       done

     

       45
       45
        
       

     

       46
       46
        
       cat >sources.nix <<EOF

+2 -2

pkgs/by-name/ya/yazi/plugins/update.py

···

       134
       134
        
               new_hash = run_command(f"nix-prefetch-url --unpack --type sha256 {prefetch_url} 2>/dev/null")

     

       135
       135
        
       

     

       136
       136
        
               if not new_hash.startswith("sha256-"):

     

       137
       137
       -
                   new_hash = run_command(f"nix hash to-sri --type sha256 {new_hash} 2>/dev/null")

     

       137
       137
       +
                   new_hash = run_command(f"nix --extra-experimental-features nix-command hash to-sri --type sha256 {new_hash} 2>/dev/null")

     

       138
       138
        
       

     

       139
       139
        
                   if not new_hash.startswith("sha256-"):

     

       140
       140
        
                       print("Warning: Failed to get SRI hash directly, trying alternative method...")

     

       141
       141
        
                       raw_hash = run_command(f"nix-prefetch-url --type sha256 {prefetch_url} 2>/dev/null")

     

       142
       142
       -
                       new_hash = run_command(f"nix hash to-sri --type sha256 {raw_hash} 2>/dev/null")

     

       142
       142
       +
                       new_hash = run_command(f"nix --extra-experimental-features nix-command hash to-sri --type sha256 {raw_hash} 2>/dev/null")

     

       143
       143
        
           except Exception as e:

     

       144
       144
        
               raise RuntimeError(f"Error calculating hash: {e}")

     

       145
       145

+3 -3

pkgs/by-name/zo/zoom-us/update.sh

···

       21
       21
        
       # causes cross compiling headaches; using nix-prefetch-url with

     

       22
       22
        
       # hard-coded URLs is simpler.  Keep these URLs in sync with the ones

     

       23
       23
        
       # in package.nix where `srcs` is defined.

     

       24
       24
       -
       hash_aarch64_darwin=$(nix hash to-sri --type sha256 $(nix-prefetch-url --type sha256 "https://zoom.us/client/${version_aarch64_darwin}/zoomusInstallerFull.pkg?archType=arm64"))

     

       25
       25
       -
       hash_x86_64_darwin=$(nix hash to-sri --type sha256 $(nix-prefetch-url --type sha256 "https://zoom.us/client/${version_x86_64_darwin}/zoomusInstallerFull.pkg"))

     

       26
       26
       -
       hash_x86_64_linux=$(nix hash to-sri --type sha256 $(nix-prefetch-url --type sha256 "https://zoom.us/client/${version_x86_64_linux}/zoom_x86_64.pkg.tar.xz"))

     

       24
       24
       +
       hash_aarch64_darwin=$(nix --extra-experimental-features nix-command hash to-sri --type sha256 $(nix-prefetch-url --type sha256 "https://zoom.us/client/${version_aarch64_darwin}/zoomusInstallerFull.pkg?archType=arm64"))

     

       25
       25
       +
       hash_x86_64_darwin=$(nix --extra-experimental-features nix-command hash to-sri --type sha256 $(nix-prefetch-url --type sha256 "https://zoom.us/client/${version_x86_64_darwin}/zoomusInstallerFull.pkg"))

     

       26
       26
       +
       hash_x86_64_linux=$(nix --extra-experimental-features nix-command hash to-sri --type sha256 $(nix-prefetch-url --type sha256 "https://zoom.us/client/${version_x86_64_linux}/zoom_x86_64.pkg.tar.xz"))

     

       27
       27
        
       

     

       28
       28
        
       echo >&2 "=== Updating package.nix ..."

     

       29
       29
        
       # update-source-version expects to be at the root of nixpkgs

+4 -4

pkgs/development/compilers/dotnet/update.sh

···

       43
       43
        
       

     

       44
       44
        
               [[ -z "$url" || -z "$hash" ]] && continue

     

       45
       45
        
       

     

       46
       46
       -
               hash=$(nix hash convert --to sri --hash-algo sha512 "$hash")

     

       46
       46
       +
               hash=$(nix --extra-experimental-features nix-command hash convert --to sri --hash-algo sha512 "$hash")

     

       47
       47
        
       

     

       48
       48
        
               echo "      $rid = {

     

       49
       49
        
               url = \"$url\";

     
···

       73
       73
        
               if hash=$(curl -s --head "$url" -o /dev/null -w '%header{x-ms-meta-sha512}') && [[ -n "$hash" ]]; then

     

       74
       74
        
                   # Undocumented fast path for nuget.org

     

       75
       75
        
                   # https://github.com/NuGet/NuGetGallery/issues/9433#issuecomment-1472286080

     

       76
       76
       -
                   hash=$(nix hash convert --to sri --hash-algo sha512 "$hash")

     

       76
       76
       +
                   hash=$(nix --extra-experimental-features nix-command hash convert --to sri --hash-algo sha512 "$hash")

     

       77
       77
        
               elif {

     

       78
       78
        
                   catalog_url=$(curl -sL --compressed "${nuget_registration_base_url}${pkg,,}/${version,,}.json" | jq -r ".catalogEntry") && [[ -n "$catalog_url" ]] &&

     

       79
       79
        
                   catalog=$(curl -sL "$catalog_url") && [[ -n "$catalog" ]] &&

     
···

       81
       81
        
                   hash=$(jq -er '.packageHash' <<<"$catalog") && [[ -n "$hash" ]]

     

       82
       82
        
               }; then

     

       83
       83
        
                   # Documented but slower path (requires 2 requests)

     

       84
       84
       -
                   hash=$(nix hash convert --to sri --hash-algo "${hash_algorithm,,}" "$hash")

     

       84
       84
       +
                   hash=$(nix --extra-experimental-features nix-command hash convert --to sri --hash-algo "${hash_algorithm,,}" "$hash")

     

       85
       85
        
               elif hash=$(nix-prefetch-url "$url" --type sha512); then

     

       86
       86
        
                   # Fallback to downloading and hashing locally

     

       87
       87
        
                   echo "Failed to fetch hash from nuget for $url, falling back to downloading locally" >&2

     

       88
       88
       -
                   hash=$(nix hash convert --to sri --hash-algo sha512 "$hash")

     

       88
       88
       +
                   hash=$(nix --extra-experimental-features nix-command hash convert --to sri --hash-algo sha512 "$hash")

     

       89
       89
        
               else

     

       90
       90
        
                   echo "Failed to fetch hash for $url" >&2

     

       91
       91
        
                   exit 1

+1 -1

pkgs/development/compilers/graalvm/graalvm-oracle/hashes.nix

···

       2
       2
        
       # https://www.oracle.com/java/technologies/javase/graalvm-jdk23-archive-downloads.html

     

       3
       3
        
       # Then run this script:

     

       4
       4
        
       # $ rg -No "(https://.+)\"" -r '$1' pkgs/development/compilers/graalvm/graalvm-oracle/hashes.nix | \

     

       5
       5
       -
       #   parallel -k 'echo {}; nix hash convert --hash-algo sha256 --to sri $(curl -s {}.sha256)'

     

       5
       5
       +
       #   parallel -k 'echo {}; nix --extra-experimental-features nix-command hash convert --hash-algo sha256 --to sri $(curl -s {}.sha256)'

     

       6
       6
        
       {

     

       7
       7
        
         "23" = {

     

       8
       8
        
           "aarch64-linux" = {

+1 -1

pkgs/development/libraries/libcef/update.sh

···

       38
       38
        
       for platform in "${platforms[@]}"; do

     

       39
       39
        
           read -r system arch <<< "$platform"

     

       40
       40
        
           url="https://cef-builds.spotifycdn.com/cef_binary_${cef_version}+g${git_revision}+chromium-${chromium_version}_linux${arch}_minimal.tar.bz2"

     

       41
       41
       -
           hash=$(nix hash convert --to sri --hash-algo sha256 "$(nix-prefetch-url --quiet "$url")")

     

       41
       41
       +
           hash=$(nix --extra-experimental-features nix-command hash convert --to sri --hash-algo sha256 "$(nix-prefetch-url --quiet "$url")")

     

       42
       42
        
           update-source-version libcef "$cef_version" "$hash" --system="$system" --ignore-same-version

     

       43
       43
        
       done

+1 -1

pkgs/development/libraries/science/math/libtorch/prefetch.sh

···

       23
       23
        
         name=$(echo "$url_and_key" | cut -d' ' -f3)

     

       24
       24
        
       

     

       25
       25
        
         echo "prefetching ${url}..."

     

       26
       26
       -
         hash=$(nix hash to-sri --type sha256 $(nix-prefetch-url --unpack "$url" --name "$name"))

     

       26
       26
       +
         hash=$(nix --extra-experimental-features nix-command hash to-sri --type sha256 $(nix-prefetch-url --unpack "$url" --name "$name"))

     

       27
       27
        
       

     

       28
       28
        
         echo "    $key = {" >> $hashfile

     

       29
       29
        
         echo "      name = \"$name\";" >> $hashfile

+1 -1

pkgs/development/python-modules/jaxlib/prefetch.sh

···

       6
       6
        
           url=$(NIX_PATH=.. nix-instantiate --eval -E "$expr" | jq -r)

     

       7
       7
        
           echo "$url"

     

       8
       8
        
           sha256=$(nix-prefetch-url "$url")

     

       9
       9
       -
           nix hash convert --to sri --hash-algo sha256 "$sha256"

     

       9
       9
       +
           nix --extra-experimental-features nix-command hash convert --to sri --hash-algo sha256 "$sha256"

     

       10
       10
        
           echo

     

       11
       11
        
       }

     

       12
       12

+1 -1

pkgs/development/python-modules/mypy-boto3/update.sh

···

       368
       368
        
         if [ "${version}" != "${old_version}" ]; then

     

       369
       369
        
           url="https://pypi.io/packages/source/m/${package//-/_}/${package//-/_}-${version}.tar.gz"

     

       370
       370
        
           hash=$(nix-prefetch-url --type sha256 $url)

     

       371
       371
       -
           sri_hash="$(nix hash to-sri --type sha256 $hash)"

     

       371
       371
       +
           sri_hash="$(nix --extra-experimental-features nix-command hash to-sri --type sha256 $hash)"

     

       372
       372
        
       

     

       373
       373
        
           awk -i inplace -v pkg="\"$package_short_name\"" -v new_version="$version" -v new_sha256="$sri_hash" '

     

       374
       374
        
             # Match the line containing the package name

+1 -1

pkgs/development/python-modules/ray/prefetch.sh

···

       13
       13
        
           url=$(NIX_PATH=.. nix-instantiate --eval -E "$expr" | jq -r)

     

       14
       14
        
       

     

       15
       15
        
           sha256=$(nix-prefetch-url "$url")

     

       16
       16
       -
           hash=$(nix hash convert --to sri --hash-algo sha256 "$sha256")

     

       16
       16
       +
           hash=$(nix --extra-experimental-features nix-command hash convert --to sri --hash-algo sha256 "$sha256")

     

       17
       17
        
       

     

       18
       18
        
           echo -e "  cp${1} = \"${hash}\";" >>$outfile

     

       19
       19
        
           echo

+1 -1

pkgs/development/python-modules/torch/bin/prefetch.sh

···

       37
       37
        
           name=$(echo "$url_and_key" | cut -d' ' -f3)

     

       38
       38
        
       

     

       39
       39
        
           echo "prefetching ${url}..."

     

       40
       40
       -
           hash=$(nix hash convert --hash-algo sha256 $(nix-prefetch-url "$url" --name "$name"))

     

       40
       40
       +
           hash=$(nix --extra-experimental-features nix-command hash convert --hash-algo sha256 $(nix-prefetch-url "$url" --name "$name"))

     

       41
       41
        
       

     

       42
       42
        
           echo "    $key = {" >>$hashfile

     

       43
       43
        
           echo "      name = \"$name\";" >>$hashfile

+1 -1

pkgs/development/python-modules/torchaudio/prefetch.sh

···

       37
       37
        
           name=$(echo "$url_and_key" | cut -d' ' -f3)

     

       38
       38
        
       

     

       39
       39
        
           echo "prefetching ${url}..."

     

       40
       40
       -
           hash=$(nix hash convert --hash-algo sha256 $(nix-prefetch-url "$url" --name "$name"))

     

       40
       40
       +
           hash=$(nix --extra-experimental-features nix-command hash convert --hash-algo sha256 $(nix-prefetch-url "$url" --name "$name"))

     

       41
       41
        
       

     

       42
       42
        
           echo "    $key = {" >>$hashfile

     

       43
       43
        
           echo "      name = \"$name\";" >>$hashfile

+1 -1

pkgs/development/python-modules/torchvision/prefetch.sh

···

       36
       36
        
           name=$(echo "$url_and_key" | cut -d' ' -f3)

     

       37
       37
        
       

     

       38
       38
        
           echo "prefetching ${url}..."

     

       39
       39
       -
           hash=$(nix hash convert --hash-algo sha256 $(nix-prefetch-url "$url" --name "$name"))

     

       39
       39
       +
           hash=$(nix --extra-experimental-features nix-command hash convert --hash-algo sha256 $(nix-prefetch-url "$url" --name "$name"))

     

       40
       40
        
       

     

       41
       41
        
           echo "    $key = {" >>$hashfile

     

       42
       42
        
           echo "      name = \"$name\";" >>$hashfile

+1 -1

pkgs/development/python-modules/types-aiobotocore/update.sh

···

       371
       371
        
       

     

       372
       372
        
         url="https://pypi.io/packages/source/t/${package}/${package//-/_}-${version}.tar.gz"

     

       373
       373
        
         hash=$(nix-prefetch-url --type sha256 $url)

     

       374
       374
       -
         sri_hash="$(nix hash convert --hash-algo sha256 --to sri $hash)"

     

       374
       374
       +
         sri_hash="$(nix --extra-experimental-features nix-command hash convert --hash-algo sha256 --to sri $hash)"

     

       375
       375
        
         package_short="${package#types-aiobotocore-}"

     

       376
       376
        
       

     

       377
       377
        
         awk -i inplace -v pkg="$package" -v pkg_short="$package_short" -v ver="$version" -v hash="$sri_hash" '

+1 -1

pkgs/development/tools/continuous-integration/woodpecker/update.sh

···

       28
       28
        
       

     

       29
       29
        
       # Woodpecker repository

     

       30
       30
        
       src_hash=$(nix-prefetch-url --type sha256 --unpack "https://github.com/woodpecker-ci/woodpecker/releases/download/v$version/woodpecker-src.tar.gz")

     

       31
       31
       -
       src_hash=$(nix hash to-sri --type sha256 "$src_hash")

     

       31
       31
       +
       src_hash=$(nix --extra-experimental-features nix-command hash to-sri --type sha256 "$src_hash")

     

       32
       32
        
       sed -i -E -e "s#srcHash = \".*\"#srcHash = \"$src_hash\"#" common.nix

+1 -1

pkgs/development/tools/infisical/update.sh

···

       29
       29
        
       for arch in "${ARCHS[@]}"; do

     

       30
       30
        
           IFS=: read -r arch_name arch_target <<< "$arch"

     

       31
       31
        
           sha256hash="$(nix-prefetch-url --type sha256 "https://github.com/infisical/infisical/releases/download/${RELEASE_NAME}/infisical_${VERSION}_${arch_target}.tar.gz")"

     

       32
       32
       -
           srihash="$(nix hash to-sri --type sha256 "$sha256hash")"

     

       32
       32
       +
           srihash="$(nix --extra-experimental-features nix-command hash to-sri --type sha256 "$sha256hash")"

     

       33
       33
        
           echo ", \"$arch_name\": \"$srihash\"" >> "$HFILE"

     

       34
       34
        
       done

     

       35
       35
        
       echo "}" >> "$HFILE"

+1 -1

pkgs/development/tools/rover/update.sh

···

       24
       24
        
       } < <(nix-prefetch-url "$rover_tar_url" --unpack --type sha256 --print-path)

     

       25
       25
        
       

     

       26
       26
        
       # Convert hash to SRI representation

     

       27
       27
       -
       rover_sri_hash=$(nix hash to-sri --type sha256 "$rover_hash")

     

       27
       27
       +
       rover_sri_hash=$(nix --extra-experimental-features nix-command hash to-sri --type sha256 "$rover_hash")

     

       28
       28
        
       

     

       29
       29
        
       # Update rover version.

     

       30
       30
        
       sed --in-place \

+1 -1

pkgs/misc/lilypond/update.sh

···

       21
       21
        
       

     

       22
       22
        
       # update hash

     

       23
       23
        
       PREV=$(nix eval --raw -f default.nix $ATTR.src.outputHash)

     

       24
       24
       -
       NEXT=$(nix hash to-sri --type sha256 $(nix-prefetch-url --type sha256 --unpack $(nix eval --raw -f default.nix $ATTR.src.url)))

     

       24
       24
       +
       NEXT=$(nix --extra-experimental-features nix-command hash to-sri --type sha256 $(nix-prefetch-url --type sha256 --unpack $(nix eval --raw -f default.nix $ATTR.src.url)))

     

       25
       25
        
       sed -i "s|$PREV|$NEXT|" "$FILE"

+1 -1

pkgs/os-specific/linux/batman-adv/version.nix

···

       4
       4
        
         # To get these, run:

     

       5
       5
        
         #

     

       6
       6
        
         # ```

     

       7
       7
       -
         # for tool in alfred batctl batman-adv; do nix-prefetch-url https://downloads.open-mesh.org/batman/releases/batman-adv-2025.2/$tool-2025.2.tar.gz --type sha256 | xargs nix hash convert --hash-algo sha256 --to sri; done

     

       7
       7
       +
         # for tool in alfred batctl batman-adv; do nix-prefetch-url https://downloads.open-mesh.org/batman/releases/batman-adv-2025.2/$tool-2025.2.tar.gz --type sha256 | xargs nix --extra-experimental-features nix-command hash convert --hash-algo sha256 --to sri; done

     

       8
       8
        
         # ```

     

       9
       9
        
         sha256 = {

     

       10
       10
        
           alfred = "sha256-Q0fR5LB5Svv2sXGoV7mjx9UaKR/FTxbNrZLH99HNtRo=";

+1 -1

pkgs/os-specific/linux/minimal-bootstrap/stage0-posix/bootstrap-sources.nix

···

       22
       22
        
       

     

       23
       23
        
           Run the following command:

     

       24
       24
        
           ```

     

       25
       25
       -
           nix hash path $(nix build --print-out-paths -f '<nixpkgs>' make-minimal-bootstrap-sources)

     

       25
       25
       +
           nix --extra-experimental-features nix-command hash path $(nix build --print-out-paths -f '<nixpkgs>' make-minimal-bootstrap-sources)

     

       26
       26
        
           ```

     

       27
       27
        
       

     

       28
       28
        
           # Why do we need this `.nar` archive?

+1 -1

pkgs/servers/etcd/3.5/update.sh

···

       27
       27
        
       if [ ! "$OLD_VERSION" = "$LATEST_VERSION" ]; then

     

       28
       28
        
           echo "Attempting to update etcd from $OLD_VERSION to $LATEST_VERSION"

     

       29
       29
        
           ETCD_SRC_HASH=$(nix-prefetch-url --quiet --unpack https://github.com/etcd-io/etcd/archive/refs/tags/${LATEST_TAG}.tar.gz)

     

       30
       30
       -
           ETCD_SRC_HASH=$(nix hash to-sri --type sha256 $ETCD_SRC_HASH)

     

       30
       30
       +
           ETCD_SRC_HASH=$(nix --extra-experimental-features nix-command hash to-sri --type sha256 $ETCD_SRC_HASH)

     

       31
       31
        
       

     

       32
       32
        
           setKV () {

     

       33
       33
        
               sed -i "s|$1 = \".*\"|$1 = \"${2:-}\"|" "$ETCD_PATH/default.nix"

+1 -1

pkgs/servers/lidarr/update.sh

···

       15
       15
        
       

     

       16
       16
        
           url="https://github.com/Lidarr/Lidarr/releases/download/v$version/Lidarr.master.$version.$os-core-$arch.tar.gz"

     

       17
       17
        
           hash=$(nix-prefetch-url --type sha256 $url)

     

       18
       18
       -
           sriHash="$(nix hash to-sri --type sha256 $hash)"

     

       18
       18
       +
           sriHash="$(nix --extra-experimental-features nix-command hash to-sri --type sha256 $hash)"

     

       19
       19
        
       

     

       20
       20
        
           sed -i "s|$hashKey = \"[a-zA-Z0-9\/+-=]*\";|$hashKey = \"$sriHash\";|g" "$dirname/default.nix"

     

       21
       21
        
       }

+1 -1

pkgs/tools/admin/ibmcloud-cli/update.sh

···

       23
       23
        
           aarch64-darwin; do

     

       24
       24
        
           tmp=$(mktemp -d)

     

       25
       25
        
           curl -fsSL -o $tmp/ibmcloud-cli $(nix-instantiate --eval -E "with import ./. {}; ibmcloud-cli.src.url" --system "$system" | tr -d '"')

     

       26
       26
       -
           hash=$(nix hash file $tmp/ibmcloud-cli)

     

       26
       26
       +
           hash=$(nix --extra-experimental-features nix-command hash file $tmp/ibmcloud-cli)

     

       27
       27
        
           update-source-version ibmcloud-cli $latestVersion $hash --system=$system --ignore-same-version

     

       28
       28
        
           rm -rf $tmp

     

       29
       29
        
       done

+1 -1

pkgs/tools/misc/xvfb-run/update.sh

···

       7
       7
        
       info=$(nix-prefetch-git --quiet --url "https://github.com/archlinux/svntogit-packages" --rev "refs/heads/packages/xorg-server")

     

       8
       8
        
       

     

       9
       9
        
       rev=$(jq -r '.rev' <<< "$info")

     

       10
       10
       -
       sha256=$(nix hash to-sri --type sha256 "$(jq -r '.sha256' <<< "$info")")

     

       10
       10
       +
       sha256=$(nix --extra-experimental-features nix-command hash to-sri --type sha256 "$(jq -r '.sha256' <<< "$info")")

     

       11
       11
        
       dir=$(jq -r '.path' <<< "$info")

     

       12
       12
        
       

     

       13
       13
        
       newXvfbsha=$(sha256sum "$dir/trunk/xvfb-run")