curl to get the JSON response for the latest releasegrep to find the line containing file URLcut and tr to extract the URLwget to download itcurl -s https://api.github.com/repos/jgm/pandoc/releases/latest \
| grep "browser_download_url.*deb" \
| cut -d : -f 2,3 \
| tr -d \" \
| wget -qi -
wget $(wget -q -O - https://api.github.com/repos/bitwarden/clients/releases/latest | jq -r '.assets[] | select(.name | contains ("deb")) | .browser_download_url')
I would say this is NOT trolling.
Just like this, IMHO.
It worked at first attempt :)
Thank you so much !!
dra is making huge strides in simplifying the download process.
dra helps you download release assets more easily:
- no authentication for public repository (you cannot use gh without authentication)
- Built-in generation of pattern to select an asset to download (with gh you need to provide glob pattern that you need to create manually).
The download with NotpadPlus x64.exe does not work.
`
@echo off
setlocal enabledelayedexpansion
set repo=notepad-plus-plus/notepad-plus-plus
for /f "tokens=1,* delims=:" %%A in ('curl -ks https://api.github.com/repos/%repo%/releases/latest ^| find "browser_download_url"') do (
call :download "%%B"
)
goto :eof
:download
set "url=%~1"
for %%i in (%url%) do set "filename=%%nxi"-9%"==".x64.exe" (
if "%filename:
curl -kOL %url%
)
goto :eof
`
I am not unsubscribing because I actually want to see how far we get, and how long this conversation lasts with all these comments that everyone keeps adding. There are hundreds of ways and different languages to achieve the same result. But do we need the rosetta stone with all the programming languages on earth, and all the different approaches, or can we move on, after having received so many comments? OMG.
" different languages"?
The title reads "One Liner to Download the Latest Release from Github Repo".
I would say that the original thing aimed at using a single line command or pipeline.
So I would say it is aimed at a shell (bash/zsh/PowerShell) not any language.
Still on a single line.
IMHO, a few comments actually hit spot.
All the rest is either multi-line scripts (no. of lines > 1) or just not working.
The title reads "One Liner to Download the Latest Release from Github Repo". I would say that the original thing aimed at using a single line command or pipeline. So I would say it is aimed at a shell (bash/zsh/PowerShell) not any language. Still on a single line.
IMHO, a few comments actually hit spot. All the rest is either multi-line scripts (no. of lines > 1) or just not working.
For a specific repository a single line to do the task can be created. BUT for a general repository, well, what is needed is next to impossible to do in one line, or even in a small script. There are always weird exceptions. I have seen many of them!
The general request that was made, was so general, it is also impossible to achieve. No one answer, or one simple line is itself a complete answer. So you get a multitude of answers, each of which will work for specific cases.
"Simplicity has a habit of expanding into catastrophe."
-- Anne McCaffrey, "The Ship who Sang"
In seeking the unattainable, simplicity only gets in the way.
-- Alan J. Perlis
Fair.
A general 1-liner, even to a specific git repo, is quite difficult to achieve.
But a 1-liner that can be easily adapted to a number of cases is a different thing and is something much easier to do.
The type of things you can look for here and in any other question-and-answers web sites.
The original 1st post here, was already a Unix shell-based solution, not a question, using 5 different commands, none aimed at JSON parsing and with inexplicably replicated functions between wget and curl. If the output from GitHub were moved to "compact JSON" (no newlines at all) by GitHub itself, then most of those JSON-unaware scripts would stop working.
The original solution, as most of the subsequent replies, has likely been created by merging 2 different sources.
I have shared my (rather limited) knowledge about scripting to get a simple, minimal and reliable 1-liner that can be easily adapted to a large number of cases.
It only uses 2 tools (wget and jq) aimed exactly at their goals (downloading via HTTP and reliably parsing JSON strings).
This is according to the Unix command line art of simplicity, IMHO.
"Life is really simple, but we insist on making it complicated."
-- Confucius
"It is not a daily increase, but a daily decrease. Hack away at the inessentials."
-- Bruce Lee
"If you can't explain it to a six year old, you don't understand it yourself."
-- Albert Einstein
Here is a solution for Windows, you need to put the repo owner and name, as well as a string to identify the download, the generic version of the command is below.
for /f "tokens=1,* delims=:" %a in ('curl -s https://api.github.com/repos/<Put repo owner and repo name here>/releases/latest ^| findstr "browser_download_url" ^| findstr "<Put identifying string here>"') do (curl -kOL %b)
Example
Putting the repo as notepad-plus-plus/notepad-plus-plus and the identifying string as .x64.exe we get this command:
for /f "tokens=1,* delims=:" %a in ('curl -s https://api.github.com/repos/notepad-plus-plus/notepad-plus-plus/releases/latest ^| findstr "browser_download_url" ^| findstr ".x64.exe"') do (curl -kOL %b)
Which downloads the latest x64 installer of Notepad++ to the current directory.
Here is the simplest way of getting the latest version with only curl and basename: Using the Forwarded url by github when accessing /latest:
basename $(curl -Ls -o /dev/null -w %{url_effective} https://github.com/<user>/<repo>/releases/latest)Here another variant of it with only curl and a pure bash feature:
version=$(curl -Ls -o /dev/null -w %{url_effective} https://github.com/<user>/<repo>/releases/latest)
version=${version##*/}
Here is the simplest way of getting the latest version with only
curlandbasename: Using the Forwarded url by github when accessing/latest:basename $(curl -Ls -o /dev/null -w %{url_effective} https://github.com/<user>/<repo>/releases/latest)Here another variant of it with only
curland a pure bash feature:version=$(curl -Ls -o /dev/null -w %{url_effective} https://github.com/<user>/<repo>/releases/latest) version=${version##*/}
works great
Using jq to match a release file pattern (modsecurity-v.*.tar.gz$ in this example):
curl -sL https://api.github.com/repos/owasp-modsecurity/ModSecurity/releases/latest| \
jq -r '.assets[] | select(.name? | match("modsecurity-v.*.tar.gz$")) | .browser_download_url'
Another simple command using the fantastic Nushell
http get https://api.github.com/repos/<user>/<repo>/releases/latest | get tag_name
here's one for getting the tag name of the latest release:
curl -s https://api.github.com/repos/<REPO>/releases/latest | jq -r '.tag_name'this is useful for cloning the latest release, eg. with asdf:
local asdf_version=$(curl -s https://api.github.com/repos/asdf-vm/asdf/releases/latest | jq -r '.tag_name')
git clone https://github.com/asdf-vm/asdf.git ~/.asdf --branch $asdf_version
wget one-liner to get release tarball and extract its contents:
wget -qO- 'https://api.github.com/repos/<REPO>/releases/latest' | jq -r '.assets[] | select(.name | match("tar.(gz|xz)")) | .browser_download_url' | xargs wget -qO- | bsdtar -xf -
Better alternative that will work even if the json is pretty or not:
curl -s https://api.github.com/repos/jgm/pandoc/releases/latest | sed 's/[()",{}]/ /g; s/ /\n/g' | grep "https.*releases/download.*deb"
Using jq -c to turn the json compact and this is what happens:
Old:
curl -s https://api.github.com/repos/jgm/pandoc/releases/latest \
| grep "browser_download_url.*deb" \
| cut -d : -f 2,3 \
| tr -d \"
https://github.com/jgm/pandoc/releases/download/3.2/pandoc-3.2-1-amd64.deb
https://github.com/jgm/pandoc/releases/download/3.2/pandoc-3.2-1-arm64.deb
curl -s https://api.github.com/repos/jgm/pandoc/releases/latest | jq -c \
| grep "browser_download_url.*deb" \
| cut -d : -f 2,3 \
| tr -d \"
https://api.github.com/repos/jgm/pandoc/releases/155373146,assets_url
Alternative:
curl -s https://api.github.com/repos/jgm/pandoc/releases/latest | sed 's/[()",{}]/ /g; s/ /\n/g' | grep "https.*releases/download.*deb"
https://github.com/jgm/pandoc/releases/download/3.2/pandoc-3.2-1-amd64.deb
https://github.com/jgm/pandoc/releases/download/3.2/pandoc-3.2-1-arm64.deb
curl -s https://api.github.com/repos/jgm/pandoc/releases/latest | jq -c | sed 's/[()",{}]/ /g; s/ /\n/g' | grep "https.*releases/download.*deb"
https://github.com/jgm/pandoc/releases/download/3.2/pandoc-3.2-1-amd64.deb
https://github.com/jgm/pandoc/releases/download/3.2/pandoc-3.2-1-arm64.deb
Fedora 40 recently changed wget for wget2, and this causes github the send the json compact breaking scripts that were parsing it with grep.
I use gron when it is available, otherwise the sed tricks should work most of the time.
This is it
wget https://github.com/aquasecurity/tfsec/releases/latest/download/tfsec-linux-amd64
this is the best solution. thank you @joshjohanning. everything else is unnecessarily complicated for users and could trip them up because of different shell versions and lack of installed libs like jq.
add in a bit of uname magic and all your users are good to go.
curl -L -o dotenvx.tar.gz "https://github.com/dotenvx/dotenvx/releases/latest/download/dotenvx-$(uname -s)-$(uname -m).tar.gz"
tar -xzf dotenvx.tar.gz
./dotenvx help
Since this gist is still very active, here's one I've made recently:
#!/usr/bin/env bash
# Fetch the latest release version
latest_version=$(curl -s https://api.github.com/repos/microsoft/vscode-js-debug/releases/latest | grep -oP '"tag_name": "\K(.*)(?=")')
# Remove the 'v' prefix from the version number
version=${latest_version#v}
# Construct the download URL
download_url="https://github.com/microsoft/vscode-js-debug/releases/download/${latest_version}/js-debug-dap-${latest_version}.tar.gz"
# Download the tar.gz file
curl -L -o "js-debug-dap-${version}.tar.gz" "$download_url"
Just curl and grep:
curl -s https://api.github.com/repos/caddyserver/xcaddy/releases/latest | grep '"browser_download_url":' | grep 'amd64.deb' | grep -vE '(\.pem|\.sig)' | grep -o 'https://[^"]*'
https://github.com/caddyserver/xcaddy/releases/download/v0.4.2/xcaddy_0.4.2_linux_amd64.deb
curl -s https://api.github.com/repos/aptly-dev/aptly/releases/latest | grep '"browser_download_url":' | grep 'amd64.deb' | grep -o 'https://[^"]*'
https://github.com/aptly-dev/aptly/releases/download/v1.5.0/aptly_1.5.0_amd64.deb
My apologies if it borrows from other answers.
dra is making huge strides in simplifying the download process.
@NiceGuyIT thanks for bringing it up.
Nice examples, thanks to all. Stil, not always is "browser_download_url" available.
Also, we should assume that *.deb is not enough, rather use amd64.deb or x86_64.deb.
It would be nice if we had permanent file name, to directly use wget of download link, but we also have file names with version.
lastversion works, just it has not in-built install for deb as for rpm.
Here is the example I assume should work for install of https://github.com/rustdesk/rustdesk/releases/latest (which does not work with most of solutions):
curl -sL https://github.com/rustdesk/rustdesk/releases/latest | grep "https.*releases/download.*amd64\|x86_64\.deb" | grep -oP 'href="\Khttps:.+?"' | sed 's/"//' | wget -i-
Or:
curl -sL https://github.com/rustdesk/rustdesk/releases/latest | grep -wo "https.*x86_64.deb\|https.*amd64.deb"
I know this gist is for latest regular release but what if you need the latest pre-release like at tasmota/install where certain assets are ONLY built in pre-releases and not in the regular ones. I was unable to get lastversion to do this even with pre-release option because of how the CI generated the pre-releases.
the operative line being
url=$(curl --silent https://api.github.com/repos/tasmota/install/releases | grep "browser_download_url\": \"" | grep $bin | head -1 | sed 's/^.*: //' | xargs)
So for example.
unset dev
if [[ $1 == "--dev" ]]; then
dev=true
shift 1
fi
chip=${1@L}
[[ $chip ]] && chip=${chip@L}
type=$2
bin=tasmota32$chip$([[ $type ]] && echo "-$type").factory.bin
if ls $bin >/dev/null 2>&1 ; then
echo $bin already exists locally so using it.
echo delete $bin first and run again to pull the latest
else
if [[ $dev ]]; then
echo downloading $bin from latest dev release
url=$(curl --silent https://api.github.com/repos/tasmota/install/releases | grep "browser_download_url\": \"" | grep $bin | head -1 | sed 's/^.*: //' | xargs)
echo downloading $url
if ! wget -O $bin "$url"; then
echo can not find any assest for $bin at Tasmota Github Install Repo
exit
fi
else
echo pulling latest regular release version of $bin
url=http://ota.tasmota.com/tasmota32/release/$bin
if ! wget -O $bin $url; then
echo could not download $bin
echo might be a development only binary try using --dev flag
exit
fi
fi
fi
Another one liner only using only wget and downloading the first (newest file from the releases):
wget -qO- --max-redirect=10 https://github.com/rustdesk/rustdesk/releases | grep -wo "https.*x86_64.deb\|https.*amd64.deb" | head -n 1 | xargs -I {} wget -O test.deb {}
not my original idea, but another way of doing this... never seen jq before, i love json so this will become a new fav...
curl -s https://api.github.com/repos/bitwarden/clients/releases/latest | jq -r '.assets[] | select(.name | contains ("zip")) | .browser_download_url' | head -n 1 | xargs -I {} wget {}
does anyone realize that piping multiple commands (from 4 up to 10) is not elegant?
And the more you insist, the more it looks bad.
1 pipe and 2 commands (curl, awk) is enough, is more effective, and it does not require installing additional tools:
URL="https://api.github.com/repos/jgraph/drawio-desktop/releases/latest"
curl -s $URL | awk -F\" '/browser_download_url.*.deb/{system("curl -OL " $(NF-1))}'
In this case it fetches two artifacts: one for ARM one for AMD64, but if you want to fetch only one artifact, you don't need another 3 pipes, and you do as follows:
URL="https://api.github.com/repos/jgraph/drawio-desktop/releases/latest"
curl -s $URL | awk -F\" '/browser_download_url.*.deb/&&/amd64/{system("curl -OL " $(NF-1))}'
Lol...
If you have the filname just do:
https://github.com/<USER>/<REPO>/releases/latest/download/<FILE_NAME>
example:
wget https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-linux-amd64
Sometimes newer versions than the latest ones are released as pre-release in repos.
An example, (Powershell) command to always download the newer version even if it is pre-release:
powershell -c "(Invoke-RestMethod -uri https://api.github.com/repos/Open-Shell/Open-Shell-Menu/releases)[0].assets.browser_download_url | Where-Object {$_ -like '*OpenShellSetup*'}"
Update Manager Class For C# APP using Github
Release the MSI after every release and update new version number to the readme file
Refer to the Gist:- Update Manager Class
Refer to the Repo:- Github Repo
private static async Task<string> GetLatestVersionFromGithub()
{
string fileUrl = "url_containing_latest_version_number";
using (HttpClient client = new HttpClient())
{
string cacheBuster = DateTime.UtcNow.Ticks.ToString();
string requestUrl = $"{fileUrl}?cb={cacheBuster}";
return await client.GetStringAsync(requestUrl);
}
}
private static void UpdateApp(string filePath)
{
string batchFilePath = Path.Combine(Path.GetTempPath(), "update.bat");
string batchScript = $@"
@echo off
echo Uninstalling program...
msiexec /x {{product_code_of_your_app}} /qb
echo Starting setup file...
start """" ""{filePath}""
";
File.WriteAllText(batchFilePath, batchScript);
Process.Start(new ProcessStartInfo(batchFilePath) { UseShellExecute = true });
Environment.Exit(0);
}
private static async Task DownloadLatestVersion()
{
var url = "https://github.com/{user_name}/{repo_name}/releases/latest/download/{name_of_msi}.msi";
var filePath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.Desktop), "PubEntrySetup.msi");
using (HttpClient client = new HttpClient())
using (HttpResponseMessage response = await client.GetAsync(url, HttpCompletionOption.ResponseHeadersRead))
using (Stream streamToReadFrom = await response.Content.ReadAsStreamAsync())
using (Stream streamToWriteTo = File.Open(filePath, FileMode.Create))
await streamToReadFrom.CopyToAsync(streamToWriteTo);
UpdateApp(filePath);
}
public static async Task CheckForUpdates()
{
string fileContent = await GetLatestVersionFromGithub();
if (fileContent.Contains("Latest Version = "))
{
string latestVersion = fileContent.Substring(fileContent.IndexOf("Latest Version = ") + 17, 7);
string currentVersion = Assembly.GetExecutingAssembly().GetName().Version.ToString();
if (latestVersion != currentVersion)
if (MessageBox.Show("New Version Available. Do you want to update?", "Update Available", MessageBoxButtons.YesNo) == DialogResult.Yes)
await DownloadLatestVersion();
}
}
From batch scripts on Windows, you can call PowerShell without directly using its shell.:
First download grep.exe from this fairly popular but unmantained repo -because findstr sucks-
powershell iwr https://github.com/bmatzelle/gow/raw/refs/heads/master/bin/grep.exe -OutFile grep.exeThen you can download your files like this.
set url=https://api.github.com/repos/user/repo/releases/latest
powershell irm %url% | grep -o 'https.*download.*zip' | powershell iwr -OutFile file.zipJust replace user/repo and zip.
for filtring and download something like beta release
curl -sL https://api.github.com/repos/telegramdesktop/tdesktop/releases
| jq -r '.[] | select(.prerelease==true) | .assets[] | select(.browser_download_url | contains("tar.xz")) | .browser_download_url'
| wget -i-
you are just trolling.