Merge c20add888b into 78b938facf

Flake lock file updates:

• Updated input 'nixpkgs':
    'https://api.flakehub.com/f/pinned/NixOS/nixpkgs/0.2505.803882%2Brev-fd487183437963a59ba763c0cc4f27e3447dd6dd/019767cd-a737-7649-ab6d-467a58ba9f92/source.tar.gz?narHash=sha256-mHv/yeUbmL91/TvV95p%2BmBVahm9mdQMJoqaTVTALaFw%3D' (2025-06-12)
  → 'https://api.flakehub.com/f/pinned/NixOS/nixpkgs/0.2505.808864%2Brev-4e7667a90c167f7a81d906e5a75cba4ad8bee620/0198eaa3-105a-74fa-a9b2-0a930acea8de/source.tar.gz?narHash=sha256-TH1SfSP523QI7kcPiNtMAEuwZR3Jdz0MCDXPs7TS8uo%3D' (2025-08-26)

Co-authored-by: github-actions[bot] <github-actions[bot]@users.noreply.github.com>

.github/workflows/lint-pr.yml

@@ -15,7 +15,7 @@ jobs:
     name: Validate pull request title
     runs-on: ubuntu-22.04
     steps:
-      - uses: amannn/action-semantic-pull-request@v5
+      - uses: amannn/action-semantic-pull-request@v6
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         with:

Formula/quickemu.rb

@@ -0,0 +1,47 @@
+class Quickemu < Formula
+  desc "Quickly create and run optimised Windows, macOS and Linux virtual machines"
+  homepage "https://github.com/quickemu-project/quickemu"
+
+  livecheck do
+    url :stable
+  end
+
+  stable do
+    latest_release = JSON.parse(Utils.safe_popen_read("curl", "-s", "https://api.github.com/repos/quickemu-project/quickemu/releases/latest"))
+    version latest_release["tag_name"]
+    url "https://api.github.com/repos/quickemu-project/quickemu/tarball/#{latest_release["tag_name"]}"
+  end
+
+  head "https://github.com/quickemu-project/quickemu.git"
+  license "MIT"
+
+  depends_on "bash"
+  depends_on "cdrtools"
+  depends_on "coreutils"
+  depends_on "jq"
+  depends_on "python3"
+  depends_on "qemu"
+  depends_on "samba"
+  depends_on "socat"
+  depends_on "swtpm"
+  depends_on "usbutils"
+  depends_on "zsync"
+
+  def install
+    bin.install "quickemu"
+    bin.install "quickget"
+  end
+
+  test do
+    # `test do` will create, run in and delete a temporary directory.
+    #
+    # This test will fail and we won't accept that! For Homebrew/homebrew-core
+    # this will need to be a test that verifies the functionality of the
+    # software. Run the test with `brew test quickemu`. Options passed
+    # to `brew install` such as `--HEAD` also need to be provided to `brew test`.
+    #
+    # The installed folder is not in the path, so use the entire path to any
+    # executables being tested: `system bin/"program", "do", "something"`.
+    system "false"
+  end
+end

flake.lock

@@ -16,12 +16,12 @@
     },
     "nixpkgs": {
       "locked": {
-        "lastModified": 1749727998,
-        "narHash": "sha256-mHv/yeUbmL91/TvV95p+mBVahm9mdQMJoqaTVTALaFw=",
-        "rev": "fd487183437963a59ba763c0cc4f27e3447dd6dd",
-        "revCount": 803882,
+        "lastModified": 1756217674,
+        "narHash": "sha256-TH1SfSP523QI7kcPiNtMAEuwZR3Jdz0MCDXPs7TS8uo=",
+        "rev": "4e7667a90c167f7a81d906e5a75cba4ad8bee620",
+        "revCount": 808864,
         "type": "tarball",
-        "url": "https://api.flakehub.com/f/pinned/NixOS/nixpkgs/0.2505.803882%2Brev-fd487183437963a59ba763c0cc4f27e3447dd6dd/019767cd-a737-7649-ab6d-467a58ba9f92/source.tar.gz"
+        "url": "https://api.flakehub.com/f/pinned/NixOS/nixpkgs/0.2505.808864%2Brev-4e7667a90c167f7a81d906e5a75cba4ad8bee620/0198eaa3-105a-74fa-a9b2-0a930acea8de/source.tar.gz"
       },
       "original": {
         "type": "tarball",

quickget

@@ -3043,7 +3043,7 @@ web_get https://www.spice-space.org/download/windows/vdagent/vdagent-win-0.10.0/
 web_get https://www.spice-space.org/download/windows/usbdk/UsbDk_1.0.22_x64.msi "${VM_PATH}/unattended"
 
 echo "Making unattended.iso"
-mkisofs -quiet -l -o "${VM_PATH}/unattended.iso" "${VM_PATH}/unattended/"
+mkisofs -quiet -J -o "${VM_PATH}/unattended.iso" "${VM_PATH}/unattended/"
 }
 
 function handle_curl_error() {

quickgetc

@@ -0,0 +1,657 @@
+#!/usr/bin/env bash
+
+CACHE_FILE="quickget_data.json.zst"
+CACHE_URL="https://github.com/lj3954/quickget_configs/releases/download/daily/quickget_data.json.zst"
+IMAGE_TYPES=("iso" "img" "fixed_iso" "floppy")
+QUICKGETC_VERSION="0.1.0"
+
+function cleanup() {
+    if [ -n "$(jobs -p)" ]; then
+        kill "$(jobs -p)" 2>/dev/null
+    fi
+}
+
+function check_hash() {
+    local iso=""
+    local hash=""
+    local hash_algo=""
+    if [ "${OPERATION}" == "download" ]; then
+        iso="${1}"
+    else
+        iso="${VM_PATH}/${1}"
+    fi
+    hash="${2}"
+    # Guess the hash algorithm by the hash length
+    case ${#hash} in
+        32) hash_algo=md5sum;;
+        40) hash_algo=sha1sum;;
+        64) hash_algo=sha256sum;;
+        128) hash_algo=sha512sum;;
+        *) echo "WARNING! Can't guess hash algorithm, not checking ${iso} hash."
+            return;;
+    esac
+    echo -n "Checking ${iso} with ${hash_algo}... "
+    if ! echo "${hash} ${iso}" | ${hash_algo} --check --status; then
+        echo "ERROR!"
+        echo "${iso} doesn't match ${hash}. Try running 'quickgetc' again."
+        exit 1
+    else
+        echo "Good!"
+    fi
+}
+
+function web_get() {
+    local CHECK=""
+    local HEADERS=()
+    local URL="${1}"
+    local DIR="${2}"
+    local FILE="${3}"
+    local USER_AGENT="Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/123.0.0.0 Safari/537.36"
+
+    # Process any URL redirections after the file name has been extracted
+    URL=$(web_redirect "${URL}")
+
+    # Process any headers
+    while (( "$#" )); do
+        if [ "${1}" == "--header" ]; then
+            HEADERS+=("${1}" "${2}")
+            shift 2
+        else
+            shift
+        fi
+    done
+
+    # Test mode for ISO
+    if [ "${OPERATION}" == "show" ]; then
+        test_result "${OS}" "${RELEASE}" "${EDITION}" "${URL}"
+        exit 0
+    elif [ "${OPERATION}" == "test" ]; then
+        CHECK=$(web_check "${URL}" && echo "PASS" || echo "FAIL")
+        test_result "${OS}" "${RELEASE}" "${EDITION}" "${URL}" "${CHECK}"
+        exit 0
+    elif [ "${OPERATION}" == "download" ]; then
+        DIR="$(pwd)"
+    fi
+
+    if [ "${DIR}" != "$(pwd)" ] && ! mkdir -p "${DIR}" 2>/dev/null; then
+        echo "ERROR! Unable to create directory ${DIR}"
+        exit 1
+    fi
+
+    if ! curl --progress-bar --location --output "${DIR}/${FILE}" --continue-at - --user-agent "${USER_AGENT}" "${HEADERS[@]}" -- "${URL}"; then
+        echo "ERROR! Failed to download ${URL} with curl."
+        rm -f "${DIR}/${FILE}"
+    fi
+}
+
+function test_result() {
+    local OS="${1}"
+    local RELEASE="${2}"
+    local EDITION="${3:-}"
+    local URL="${4:-}"
+    local RESULT="${5:-}"
+    if [ -n "${EDITION}" ]; then
+        OS="${OS}-${RELEASE}-${EDITION}"
+    else
+        OS="${OS}-${RELEASE}"
+    fi
+
+    if [ -n "${RESULT}" ]; then
+        # Pad the OS string for consistent output
+        OS=$(printf "%-35s" "${OS}")
+        echo -e "${RESULT}: ${OS} ${URL}"
+    else
+        OS=$(printf "%-36s" "${OS}:")
+        echo -e "${OS} ${URL}"
+    fi
+}
+
+# checks if a URL needs to be redirected and returns the final URL
+function web_redirect() {
+    local REDIRECT_URL=""
+    local URL="${1}"
+    # Check for URL redirections
+    # Output to nonexistent directory so the download fails fast
+    REDIRECT_URL=$(curl --silent --location --fail --write-out '%{url_effective}' --output /var/cache/${RANDOM}/${RANDOM} "${URL}")
+    if [ "${REDIRECT_URL}" != "${URL}" ]; then
+        echo "${REDIRECT_URL}"
+    else
+        echo "${URL}"
+    fi
+}
+
+# checks if a URL is reachable
+function web_check() {
+    local HEADERS=()
+    local URL="${1}"
+    # Process any headers
+    while (( "$#" )); do
+        if [ "${1}" == "--header" ]; then
+            HEADERS+=("${1}" "${2}")
+            shift 2
+        else
+            shift
+        fi
+    done
+    curl --silent --location --head --output /dev/null --fail --connect-timeout 30 --max-time 30 --retry 3 "${HEADERS[@]}" "${URL}"
+}
+
+function get_homepage() {
+    jq -r '.homepage' <<< "${OS_ENTRY}"
+}
+
+function get_description() {
+    jq -r '.description' <<< "${OS_ENTRY}"
+}
+
+function show_os_info() {
+    local HOMEPAGE
+    local DESCRIPTION
+    
+    HOMEPAGE=$(get_homepage)
+    DESCRIPTION=$(get_description)
+
+    echo -e "\n${PRETTY_NAME}"
+    if [ -n "${HOMEPAGE}" ]; then
+        echo " - Website: ${HOMEPAGE}"
+    fi
+    if [ -n "${DESCRIPTION}" ]; then
+        echo -e " - Description: ${DESCRIPTION}"
+    fi
+}
+
+function list_json() {
+    # Reference: https://stackoverflow.com/a/67359273
+    list_csv | jq -R 'split(",") as $h|reduce inputs as $in ([]; . += [$in|split(",")|. as $a|reduce range(0,length) as $i ({};.[$h[$i]]=$a[$i])])'
+
+    exit 0
+}
+
+function list_csv() {
+    echo "Display Name,OS,Release,Option,Downloader,PNG,SVG"
+
+    jq -r '.[] | .name as $name | .pretty_name as $pretty_name | .releases[] | [$name, $pretty_name, .release, .edition, null, "https://quickemu-project.github.io/quickemu-icons/png/\($name)/\($name)-quickemu-white-pinkbg.png", "https://quickemu-project.github.io/quickemu-icons/svg/\($name)/\($name)-quickemu-white-pinkbg.svg"] | @tsv' <<< "${JSON}" | tr "\t" ","
+
+    exit 0
+}
+
+function unsupported_arch() {
+    echo "ERROR! ${ARCH} is not a supported architecture for ${PRETTY_NAME} ${RELEASE}${EDITION:+ $EDITION}."
+    echo " - Supported architectures: $(jq -s -r '[.[] | .arch] | join(" ")' <<< "${EDITION_ENTRIES}")"
+    exit 1
+}
+
+function find_edition_entry() {
+    EDITION="${1}"
+    local EDITION_ENTRIES
+
+    if [ -n "${EDITION}" ]; then
+        EDITION_ENTRIES=$(jq -c 'select(.edition=="'"${EDITION}"'")' <<< "${RELEASE_ENTRIES}")
+    else
+        EDITION_ENTRIES=$(jq -c '. | select(.edition==null)' <<< "${RELEASE_ENTRIES}")
+    fi
+    if [ -z "${EDITION_ENTRIES}" ]; then
+        error_not_supported_edition
+    fi
+
+    local PREFERRED_ARCH="${ARCH:-$(uname -m)}"
+    ENTRY=$(jq -c '. | select(.arch=="'"${PREFERRED_ARCH}"'")' <<< "${EDITION_ENTRIES}")
+
+    if [ -z "${ENTRY}" ]; then
+        if [ -n "${ARCH}" ]; then
+            unsupported_arch
+        else
+            ENTRY=$(jq -c '.[0]' <<< "${EDITION_ENTRIES}")
+        fi
+    fi
+}
+
+function error_specify_edition() {
+    show_os_info
+    echo -e " - Editions:\t$(list_editions "${RELEASE}" | fold -s -w "$(tput cols)")"
+    echo -e "\nERROR! You must specify an edition."
+    exit 1
+}
+
+function list_editions() {
+    local RELEASE=${1}
+    jq -r '[.releases[] | select(.release=="'"${RELEASE}"'") | .edition] | unique | join(" ")' <<< "${OS_ENTRY}"
+}
+
+function error_no_edition_required() {
+    echo "ERROR! ${PRETTY_NAME} ${RELEASE} does not require an edition."
+    exit 1
+}
+
+function error_specify_release() {
+    show_os_info
+    list_releases
+}
+
+function release_requires_edition() {
+    [ "$(jq -s 'any(.[]; .edition == null)' <<< "${RELEASE_ENTRIES}")" == "false" ]
+}
+
+function list_releases() {
+    local CURRENT_EDITIONS
+    RELEASES=$(list_releases_raw)
+    declare -A EDITIONS
+    for RELEASE in ${RELEASES}; do
+        CURRENT_EDITIONS=$(list_editions "${RELEASE}")
+        EDITIONS["${RELEASE}"]=${CURRENT_EDITIONS}
+
+        if [ "${CURRENT_EDITIONS}" != "${EDITIONS["${RELEASES%% *}"]}" ]; then
+            UNIQUE_EDITIONS=1
+        elif [ "${CURRENT_EDITIONS}" ]; then
+            HAS_EDITIONS=1
+        fi
+    done
+
+
+    if [ "${UNIQUE_EDITIONS}" ]; then
+        printf " - %-15s | %s\n" "Releases" "Editions"
+        for RELEASE in ${RELEASES}; do
+            printf "  %-16s | %s\n" "${RELEASE}" "$(echo "${EDITIONS["${RELEASE}"]}" | tr "!" " ")"
+        done
+    else
+        echo " - Releases: $(list_releases_raw)"
+        if [ "${HAS_EDITIONS}" ]; then
+            echo " - Editions: ${CURRENT_EDITIONS}"
+        fi
+    fi
+}
+
+function list_releases_raw() {
+    # Reference: https://unix.stackexchange.com/questions/738691/get-unique-without-sorting-in-jq
+    jq -r 'reduce (.releases[].release) as $a ([]; if IN(.[]; $a) then . else . += [$a] end) | join(" ")' <<< "${OS_ENTRY}"
+}
+
+function find_release_entries() {
+    RELEASE="${1}"
+
+    RELEASE_ENTRIES="$(jq -c '.releases[] | select(.release=="'"${RELEASE}"'")' <<< "${OS_ENTRY}")"
+
+    if [ -z "${RELEASE_ENTRIES}" ]; then
+        echo -e "ERROR! ${PRETTY_NAME} ${RELEASE} is not a supported release.\n"
+        list_releases | fold -s -w "$(tput cols)"
+        exit 1
+    fi
+}
+
+function os_support() {
+    jq -r '[.[] | .name] | join(" ")' <<< "${JSON}"
+}
+
+function error_specify_os() {
+    echo "ERROR! You must specify an operating system."
+    echo "- Supported Operating Systems:"
+    os_support | fold -s -w "$(tput cols)"
+    echo -e "\nTo see all possible arguments, use:\n   quickgetc -h  or  quickgetc --help"
+    exit 1
+}
+
+function find_os_entry() {
+    OS="${1}"
+
+    OS_ENTRY="$(jq -c '.[] | select(.name=="'"${OS}"'") | .releases[] |= (. + {arch: (.arch // "x86_64"), release: (.release // "latest")})' <<< "${JSON}")"
+
+    if [ -z "${OS_ENTRY}" ]; then
+        echo -e "ERROR! ${OS} is not a supported OS.\n"
+        os_support | fold -s -w "$(tput cols)"
+    fi
+    PRETTY_NAME=$(jq -r '.pretty_name' <<< "${OS_ENTRY}")
+}
+
+function supported_archs() {
+    echo x86_64 aarch64 riscv64
+}
+
+function set_arch() {
+    case "${1}" in
+        x86_64|amd64) ARCH="x86_64";;
+        aarch64|arm64|armv8) ARCH="aarch64";;
+        riscv64|riscv) ARCH="riscv64";;
+        *)
+            echo "ERROR! ${1} is not a supported architecture."
+            echo " - Supported architectures: $(supported_archs)"
+            exit 1;;
+    esac
+}
+
+function cache_is_valid() {
+    if [ ! -f "${1}" ]; then
+        return 1
+    fi
+
+    CURRENT_DAY=$(date -u +%j%Y)
+    CACHE_DAY=$(date -u -d "$(stat -c %y "${1}")" +%j%Y)
+
+    if [ "${CURRENT_DAY}" -ne "${CACHE_DAY}" ]; then
+        return 1
+    else 
+        return 0
+    fi
+}
+
+function populate_cache() {
+    local CACHE_DIR="${XDG_CACHE_HOME:-${HOME}/.cache}"
+    if ! cache_is_valid "${CACHE_DIR}/${CACHE_FILE}"; then
+        echo "Downloading quickget data from ${CACHE_URL}"
+        web_get "${CACHE_URL}" "${CACHE_DIR}" "${CACHE_FILE}"
+    fi 
+    if ! JSON=$(zstd -dc "${CACHE_DIR}/${CACHE_FILE}"); then
+        echo "ERROR! Failed to decompress ${CACHE_DIR}/${CACHE_FILE}. Try running quickgetc again."
+        rm "${CACHE_DIR}/${CACHE_FILE}"
+        exit 1
+    fi
+}
+
+function open_homepage() {
+    find_os_entry "${1}"
+    local URL
+    URL=$(get_homepage)
+    if [ -n "${URL}" ]; then
+        xdg-open "${URL}" || sensible-browser "${URL}" || x-www-browser "${URL}" || gnome-open "${URL}"
+    else
+        echo "ERROR! No homepage found for ${PRETTY_NAME}"
+    fi
+}
+
+
+function handle_sources() {
+    local IMAGE_TYPE
+    local SOURCE
+
+    for IMAGE_TYPE in "${IMAGE_TYPES[@]}"; do
+        SOURCE=$(jq -r '."'${IMAGE_TYPE}'"[0]' <<< "${ENTRY}")
+        if [ "${SOURCE}" != "null" ]; then
+            handle_source_type "${IMAGE_TYPE}" "${SOURCE}"
+        fi
+    done
+}
+
+function handle_source_type() {
+    local IMAGE_TYPE="${1}"
+    local SOURCE="${2}"
+    local WEB_SOURCE
+    local FILE_NAME
+    local CUSTOM
+
+    WEB_SOURCE=$(jq -r '.web // ""' <<< "${SOURCE}")
+    FILE_NAME=$(jq -r '.file_name// ""' <<< "${SOURCE}")
+    CUSTOM=$(jq -r '.custom // ""' <<< "${SOURCE}")
+
+    if [ "${WEB_SOURCE}" ]; then
+        handle_websource "${IMAGE_TYPE}" "${WEB_SOURCE}"
+    elif [ "${FILE_NAME}" ]; then
+        IMAGES["${IMAGE_TYPE}"]="${VM_PATH}/${FILE_NAME}"
+    elif [ "${CUSTOM}" ]; then
+        echo "ERROR! Custom source not implemented"
+        exit 1
+    else
+        echo "ERROR! No source found for ${IMAGE_TYPE}"
+        exit 1
+    fi
+}
+
+function handle_websource() {
+    local IMAGE_TYPE="${1}"
+    local SOURCE="${2}"
+    local URL
+    local CHECKSUM
+    local ARCHIVE_FORMAT
+    local FILE_NAME
+
+    URL=$(jq -r '.url' <<< "${SOURCE}")
+    CHECKSUM=$(jq -r '.checksum // ""' <<< "${SOURCE}")
+    ARCHIVE_FORMAT=$(jq -r '.archive_format // ""' <<< "${SOURCE}")
+    FILE_NAME=$(jq -r '.file_name' <<< "${SOURCE}")
+
+    if [ "${FILE_NAME}" == "null" ]; then
+        FILE_NAME="${URL##*/}"
+    fi
+
+    web_get "${URL}" "${VM_PATH}" "${FILE_NAME}"
+    if [ -n "${CHECKSUM}" ]; then
+        check_hash "${FILE_NAME}" "${CHECKSUM}"
+    fi
+
+    if [ "${OPERATION}" = "download" ]; then
+        FINAL_FILE="${FILE_NAME}"
+        VM_PATH="$(pwd)"
+    else
+        FINAL_FILE="${VM_PATH}/${FILE_NAME}"
+    fi
+
+    case "${ARCHIVE_FORMAT}" in
+        tar*)
+            tar xf "${FINAL_FILE}" -C "${VM_PATH}"
+            IMAGES["${IMAGE_TYPE}"]="$(ls -1 "${VM_PATH}/"*".${IMAGE_TYPE}")"
+            ;;
+        xz)
+            xz -d "${FINAL_FILE}"
+            IMAGES["${IMAGE_TYPE}"]="${FINAL_FILE/.xz/}"
+            ;;
+        gz)
+            gzip -d "${FINAL_FILE}"
+            IMAGES["${IMAGE_TYPE}"]="${FINAL_FILE/.gz/}"
+            ;;
+        bz2)
+            bzip2 -d "${FINAL_FILE}"
+            IMAGES["${IMAGE_TYPE}"]="${FINAL_FILE/.bz2/}"
+            ;;
+        zip)
+            unzip -d "${VM_PATH}" "${FINAL_FILE}"
+            IMAGES["${IMAGE_TYPE}"]="$(ls -1 "${VM_PATH}/"*".${IMAGE_TYPE}")"
+            ;;
+        *)
+            IMAGES["${IMAGE_TYPE}"]="${FINAL_FILE}"
+            ;;
+    esac
+}
+
+function make_vm_config() {
+    local CONF_FILE
+    local ARCH
+    local GUEST_OS
+    # Add correct logic for disks later
+    local DISK_IMG="${VM_PATH}/disk.qcow2"
+    
+    if [ "${OPERATION}" == "download" ]; then
+        exit 0
+    fi
+
+    GUEST_OS=$(jq -r '.guest_os' <<< "${ENTRY}")
+    ARCH=$(jq -r '.arch' <<< "${ENTRY}")
+    RAM=$(jq -r '.ram // ""' <<< "${ENTRY}")
+
+    CONF_FILE="${VM_PATH}.conf"
+
+    if [ ! -e "${CONF_FILE}" ]; then
+        echo "Making ${CONF_FILE}"
+        cat << EOF > "${CONF_FILE}"
+#!$(which quickemu) --vm
+guest_os="${GUEST_OS}"
+disk_img="${DISK_IMG}"
+arch_vm="${ARCH}"
+EOF
+        echo " - Setting ${CONF_FILE} executable"
+        chmod u+x "${CONF_FILE}"
+        
+        for IMAGE in "${!IMAGES[@]}"; do
+            echo "${IMAGE}='"'${IMAGES["${IMAGE}"]}'"'" >> "${CONF_FILE}"
+        done
+
+        if [ -n "${RAM}" ]; then
+            echo "ram=$((${RAM} / 1024 / 1024 / 1024))" >> "${CONF_FILE}"
+        fi
+    fi
+}
+
+function create_vm() {
+    local DISKS
+
+    declare -A IMAGES
+
+    handle_sources
+    make_vm_config
+}
+
+function help_message() {
+    #shellcheck disable=SC2016
+    printf '
+             _      _              _
+  __ _ _   _(_) ___| | ____ _  ___| |_      ___
+ / _` | | | | |/ __| |/ / _` |/ _ \ __     / __|
+| (_| | |_| | | (__|   < (_| |  __/ |_    | (__
+ \__, |\__,_|_|\___|_|\_\__, |\___|\__|___ \___|
+    |_|                 |___/ v%s, using curl %s
+--------------------------------------------------------------------------------
+ Project - https://github.com/quickemu-project/quickemu
+ Discord - https://wimpysworld.io/discord
+--------------------------------------------------------------------------------
+
+Usage:
+  quickgetc <os> <release> [edition]
+  quickgetc ubuntu 22.04
+
+Advanced usage:
+  quickgetc <arg> [path] <os> [release] [edition]
+  quickgetc --download ubuntu 22.04
+
+Arguments:
+  --arch          <arch>                   : Specify the image architecture
+  --download      <os> <release> [edition] : Download image; no VM configuration
+  --create-config <os> [path/url]          : Create VM config for a OS image
+  --open-homepage <os>                     : Open homepage for the OS
+  --show          [os]                     : Show OS information
+  --version                                : Show version
+  --help                                   : Show this help message
+-------------------------- For testing & development ---------------------------
+  --url           [os] [release] [edition] : Show image URL(s)
+  --check         [os] [release] [edition] : Check image URL(s)
+  --list                                   : List all supported systems
+  --list-csv                               : List everything in csv format
+  --list-json                              : List everything in json format
+--------------------------------------------------------------------------------
+
+Supported Operating Systems:\n\n' "${QUICKGETC_VERSION}" "${CURL_VERSION}"
+    os_support | fold -s -w "$(tput cols)"
+}
+
+trap cleanup EXIT
+
+if ((BASH_VERSINFO[0] < 4)); then
+    echo "Sorry, you need bash 4.0 or newer to run this script."
+    exit 1
+fi
+
+OPERATION=""
+CURL=$(command -v curl)
+if [ ! -x "${CURL}" ]; then
+    echo "ERROR! curl not found. Please install curl"
+    exit 1
+fi
+CURL_VERSION=$("${CURL}" --version | head -n +1 | cut -d' ' -f2)
+
+QEMU_IMG=$(command -v qemu-img)
+if [ ! -x "${QEMU_IMG}" ]; then
+    echo "ERROR! qemu-img not found. Please make sure qemu-img is installed."
+    exit 1
+fi
+
+populate_cache
+
+case "${1}" in
+    --arch|-arch|-a)
+        shift
+        if [ -z "${1}" ]; then
+            echo "ERROR! You must specify an architecture."
+            echo " - Supported architectures: $(supported_archs)"
+            exit 1
+        fi
+        set_arch "${1}"
+        shift
+        ;;
+    --download|-download)
+        OPERATION="download"
+        shift
+        ;;
+    --create-config|-create-config)
+        OPERATION="config"
+        shift
+        create_config "${@}"
+        ;;
+    --open-homepage|-open-homepage)
+        shift
+        open_homepage "${1}"
+        ;;
+    --show|-show)
+        shift
+        if [ -z "${1}" ]; then
+            for OS in $(os_support); do
+                find_os_entry "${OS}"
+                show_os_info
+            done
+        else
+            find_os_entry "${1,,}"
+            show_os_info
+        fi
+        exit 0;;
+    --version|-version|-V)
+        echo "${QUICKGETC_VERSION}"
+        exit 0;;
+    --help|-help|--h|-h)
+        help_message
+        exit 0;;
+    --url|-url)
+        OPERATION="show"
+        shift
+        if [ -z "${1}" ]; then
+            for OS in $(os_support); do
+                (test_all "${OS}")
+            done
+            exit 0
+        elif [ -z "${2}" ]; then
+            test_all "${1}"
+            exit 0
+        fi;;
+    --list-csv|-list-csv|list|list_csv) list_csv;;
+    --list-json|-list-json|list_json) list_json;;
+    --list|-list) list_supported;;
+    -*) error_not_supported_argument;;
+esac
+
+if [ -n "${1}" ]; then
+    find_os_entry "${1,,}"
+else
+    error_specify_os
+fi
+
+if [ -n "${2}" ]; then
+    find_release_entries "${2}"
+    VM_PATH="${OS}-${RELEASE}"
+
+    if release_requires_edition; then
+        if [ -n "${3}" ]; then
+            find_edition_entry "${3}"
+            VM_PATH+="-${EDITION}"
+        else
+            error_specify_edition
+        fi
+    elif [ -n "${3}" ]; then
+        error_no_edition_required
+    else
+        find_edition_entry
+    fi
+
+    if [ -n "${ARCH}" ]; then
+        VM_PATH+="-${ARCH}"
+    fi
+
+    create_vm
+else
+    error_specify_release
+fi
+
+# vim:tabstop=4:shiftwidth=4:expandtab