.cargo/config.toml

+[target.aarch64-unknown-redox]
+linker = "aarch64-unknown-redox-gcc"
+rustflags = []
+
+[target.i686-unknown-redox]
+linker = "i686-unknown-redox-gcc"
+rustflags = []
+
+[target.x86_64-unknown-redox]
+linker = "x86_64-unknown-redox-gcc"
+rustflags = []
+
+[target.riscv64gc-unknown-redox]
+linker = "riscv64-unknown-redox-gcc"
+rustflags = []
+
+[env]
+CFLAGS_riscv64gc_unknown_redox="-march=rv64gc -mabi=lp64d"

.gitignore

-build
-repo
-stage
-stage.tar
+/build
+/repo
+source
+source.tmp
+source-new
+source.tar
+source.tar.tmp
+target

.gitmodules

+[submodule "docgen"]
+	path = docgen
+	url = https://gitlab.redox-os.org/redox-os/docgen.git
+	branch = master
+[submodule "pkgar"]
+	path = pkgar
+	url = https://gitlab.redox-os.org/redox-os/pkgar.git
+	branch = master

Cargo.toml

+[package]
+name = "redox_cookbook"
+version = "0.1.0"
+authors = ["Jeremy Soller <jackpot51@gmail.com>"]
+edition = "2018"
+default-run = "cook"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[[bin]]
+name = "cook"
+path = "src/bin/cook.rs"
+
+[[bin]]
+name = "cookbook_redoxer"
+path = "src/bin/cookbook_redoxer.rs"
+
+[lib]
+name = "cookbook"
+path = "src/lib.rs"
+
+[dependencies]
+blake3 = "=1.5.3" # 1.5.4 is incompatible with blake3 0.3 dependency from pkgar
+pbr = "1.0.2"
+pkgar = { path = "pkgar/pkgar" }
+pkgar-keys = { path = "pkgar/pkgar-keys" }
+redoxer = "0.2"
+serde = { version = "=1.0.197", features = ["derive"] }
+termion = "4"
+toml = "0.8"
+walkdir = "2.3.1"

README.md

-# cookbook
-A collection of package recipes
+# Cookbook
+
+Package system of Redox.
+
+This repository contains the system source code and packages inside the `recipes` folder.
+
+- A recipe can be a software port or system package (they use `pkgar` or `tar.gz` formats).
+
+**Read [this](https://doc.redox-os.org/book/porting-applications.html) page before porting programs to Redox**
+
+In order for this repository to be useful, it must be set up with an environment
+from the [redox](https://gitlab.redox-os.org/redox-os/redox) repository.
+
+[![MIT licensed](https://img.shields.io/badge/license-MIT-blue.svg)](./LICENSE)
+
+- [Recipe Categories](#recipe-categories)
+- [Search Recipes](#search-recipes)
+- [Package Policy](#package-policy)
+    - [Cross-Compilation](#cross-compilation)
+    - [Library Linking](#library-linking)
+    - [ABI stability](#abi-stability)
+    - [Checksum](#checksum)
+    - [License](#license)
+- [Testing Area](#testing-area)
+    - [Suggestions for TODOs](#suggestions-for-todos)
+- [Repository Layout](#repository-layout)
+- [TODO](#todo)
+
+### Recipe Categories
+
+The categories inside the `recipes` folder.
+
+- `core` - System components
+- `demos` - Programs with demos and examples
+- `dev` - Programs used for development and programming languages, like compilers and dependency managers
+- `doc` - Programs used for documentation
+- `emulators` - Console emulators or compatibility layers
+- `fonts` - Fonts and programs for fonts
+- `games` - Any kind of game
+- `graphics` - Programs used for graphics processing or production
+- `gui` - Orbital
+- `icons` - Icon packs
+- `libs` - Software with functions for other softwares, like OpenSSL
+- `math` - Programs used for calculations
+- `net` - Networking tools
+- `other` - Software that can't fit on other categories
+- `shells` - Terminal interpreters and extensions
+- `sound` - Software used for sound processing or production
+- `tests` - Software used to test other softwares
+- `tools` - Text editors, terminal tools and any other kind of tools
+- `tui` - Programs with a [terminal user interface](https://en.wikipedia.org/wiki/Text-based_user_interface)
+- `video` - Programs used for video playback, processing and production
+- `web` - World Wide Web browsers and tools
+- `wip` - Software that needs porting or incomplete recipes
+
+### Search Recipes
+
+Click in the button named "Find file" on the top of this repository to search for recipe names.
+
+### Package Policy
+
+Before sending your recipe to upstream (to become a public package), you must follow these rules:
+
+#### Cross-Compilation
+
+- All recipes must use our cross-compilers, a Cookbook [template](https://doc.redox-os.org/book/porting-applications.html#templates) does this automatically but it's not always possible, study the build system of your program or library to find these options or patch the configuration files.
+- Don't hardcode the CPU architecture on the recipe script (this would break the multi-arch support).
+
+#### Tarballs
+
+- Don't use the auto-generated tarballs from GitHub, they aren't static and don't verify the archive integrity.
+
+#### Library Linking
+
+- Keep the static linking of libraries to reduce the launch time and improve security.
+- If your package is bigger than 50MB, dynamic link big libraries until your package is equal or less than 50MB (to reduce the RAM usage).
+
+#### ABI stability
+
+- Respect the ABI separation of the libraries, for example, if `openssl1` is available and some program need `openssl3`, you will create a recipe for `openssl3` and not rename the `openssl1`, as it will break the dependent packages.
+
+#### Checksum
+
+- If your recipe download a tarball, you will need to create a BLAKE3 hash for it. You can learn how to do it [here](https://doc.redox-os.org/book/porting-applications.html#create-a-blake3-hash-for-your-recipe).
+
+#### License
+
+- Don't package programs or libraries lacking a license.
+- Verify if the program has some license violation, in case of doubt ask us on the [chat](https://doc.redox-os.org/book/chat.html).
+- Non-free programs and assets should go to a subcategory of the `nonfree` category and be approved per license.
+
+### Testing Area
+
+Work-in-progress software ports goes to the `wip` category, be aware of these items during your packaging process:
+
+- A recipe is considered ready if it's mostly working inside of Redox.
+- All WIP recipes must have a `#TODO` on the beginning of the `recipe.toml` and explain what is missing.
+- BLAKE3 hashes for tarballs are optional (quick testing workflow)
+- Try to keep the recipe with the latest stable version of the program (the porting process can take months).
+- Once the recipe is ready, add the BLAKE3 hash if needed and move the folder to the appropriate category.
+
+#### Suggestions for TODOs
+
+These TODOs improve the packagers cooperation and understanding.
+
+- `not compiled or tested` - It means that your recipe is fully configured and don't lack necessary dependencies.
+- `missing script for x, see insert-the-link-for-build-instructions-here` - It means that your recipe is lacking the cross-compilation script for some build system, where `x` is the build system name. After `see` you will insert the link for the build instructions of the program or library, it will help other packagers to insert the script for you.
+- `missing dependencies, see insert-the-link-for-required-dependencies-here` - It means that the `dependencies = []` section is incomplete.
+- `probably wrong script, see insert-the-link-for-build-instructions-here` - It means that you don't know if your script will work.
+- `probably wrong template, see insert-the-link-for-build-instructions-here` - It means that you don't know if the Cookbook template will work.
+- `probably missing dependencies, see insert-the-link-for-required-dependencies-here` - It means that you don't know if the required dependencies are satisfied.
+- `promote` - It means that the recipe is working and should be moved to the equivalent category at `cookbook/recipes`
+
+Other TODOs are specific and won't be covered on this list.
+
+### Repository Layout
+
+- `.cargo` - Cargo configuration.
+- `bin` - LLVM and pkg-config CPU targets.
+- `recipes` - Package configuration files.
+- `src` - Package system source code.
+
+### TODO
+
+- Convert old recipes to TOML, see [this](https://gitlab.redox-os.org/redox-os/cookbook/-/issues/174) tracking issue.
+- Remove the scripts after full TOML conversion.

all.sh

-for recipe in `ls -1 recipes | grep -v libstd`
-do
-    ./cook.sh $recipe $*
-done

bin/aarch64-unknown-redox-pkg-config

+#!/usr/bin/env bash
+
+export PKG_CONFIG_SYSROOT_DIR="${COOKBOOK_SYSROOT}"
+export PKG_CONFIG_LIBDIR="${PKG_CONFIG_SYSROOT_DIR}/lib/pkgconfig"
+export PKG_CONFIG_PATH="${PKG_CONFIG_SYSROOT_DIR}/share/pkgconfig"
+
+exec pkg-config --static "$@"

bin/i686-unknown-redox-pkg-config

+#!/usr/bin/env bash
+
+export PKG_CONFIG_SYSROOT_DIR="${COOKBOOK_SYSROOT}"
+export PKG_CONFIG_LIBDIR="${PKG_CONFIG_SYSROOT_DIR}/lib/pkgconfig"
+export PKG_CONFIG_PATH="${PKG_CONFIG_SYSROOT_DIR}/share/pkgconfig"
+
+exec pkg-config --static "$@"

bin/riscv64-unknown-redox-pkg-config

+#!/usr/bin/env bash
+
+export PKG_CONFIG_SYSROOT_DIR="${COOKBOOK_SYSROOT}"
+export PKG_CONFIG_LIBDIR="${PKG_CONFIG_SYSROOT_DIR}/lib/pkgconfig"
+export PKG_CONFIG_PATH="${PKG_CONFIG_SYSROOT_DIR}/share/pkgconfig"
+
+exec pkg-config --static "$@"

bin/x86_64-unknown-redox-pkg-config

+#!/usr/bin/env bash
+
+export PKG_CONFIG_SYSROOT_DIR="${COOKBOOK_SYSROOT}"
+export PKG_CONFIG_LIBDIR="${PKG_CONFIG_SYSROOT_DIR}/lib/pkgconfig"
+export PKG_CONFIG_PATH="${PKG_CONFIG_SYSROOT_DIR}/share/pkgconfig"
+
+exec pkg-config --static "$@"

clean.sh

+#!/usr/bin/env bash
+set -e
+
+source config.sh
+
+if [ $# = 0 ]
+then
+    recipes="$(target/release/list_recipes)"
+else
+    recipes="$@"
+fi
+
+for recipe_path in $recipes
+do
+    ./cook.sh "$recipe_path" distclean
+done

config.sh

+#!/usr/bin/env bash
+set -e
+
+# Configuration
+if [ -z "${TARGET}" ]
+then
+    export TARGET=x86_64-unknown-redox
+fi
+ARCH="${TARGET%%-*}"
+HOST="$TARGET"
+if [ x"${HOST}" == x"riscv64gc-unknown-redox" ] ; then
+	HOST="riscv64-unknown-redox"
+fi
+
+# Automatic variables
+ROOT="$(cd `dirname "$0"` && pwd)"
+REPO="$ROOT/repo/$TARGET"
+export PATH="${ROOT}/bin:$PATH"
+
+export AR="${HOST}-gcc-ar"
+export AS="${HOST}-as"
+export CC="${HOST}-gcc"
+export CXX="${HOST}-g++"
+export LD="${HOST}-ld"
+export NM="${HOST}-gcc-nm"
+export OBJCOPY="${HOST}-objcopy"
+export OBJDUMP="${HOST}-objdump"
+export PKG_CONFIG="${HOST}-pkg-config"
+export RANLIB="${HOST}-gcc-ranlib"
+export READELF="${HOST}-readelf"
+export STRIP="${HOST}-strip"
+
+BUILD="$(cc -dumpmachine)"
+
+export PKG_CONFIG_FOR_BUILD="pkg-config"
+
+if [[ "$OSTYPE" == "darwin"* ]] || [[ "$OSTYPE" == "FreeBSD" ]]; then
+    # GNU find
+    FIND="gfind";
+
+    # GNU stat from Homebrew or MacPorts
+    if [ ! -z "$(which brew)" ]; then
+        STAT="$(brew --prefix)/opt/coreutils/libexec/gnubin/stat";
+    elif [ ! -z "$(which port)" ]; then
+        # TODO: find a programatic way of asking MacPorts for it's root dir.
+        STAT="/opt/local/opt/coreutils/libexec/gnubin/stat";
+    elif [ ! -z "$(which pkg)" ]; then
+        STAT="gnustat"
+    else
+        echo "Please install either Homebrew or MacPorts and run the boostrap script."
+        exit 1
+    fi
+else
+    FIND="find"
+    STAT="stat";
+fi
+
+export FIND
+export STAT
+
+if [ ! "$(uname -s)" = "Redox" ]
+then
+function docgen {
+    "$ROOT/docgen/target/release/docgen" "$@"
+}
+
+function pkgar {
+    "$ROOT/pkgar/target/release/pkgar" "$@"
+}
+fi

cook.sh

-#!/bin/bash
+#!/usr/bin/env bash
+set -e
+shopt -s nullglob
+
+source config.sh
 
-export RUST_TARGET_PATH="$PWD/targets"
-export RUSTFLAGS="--cfg redox"
+# Variables to be overriden by recipes
+export BINDIR=bin
+export CARGO=(env RUSTFLAGS="$PREFIX_RUSTFLAGS -C link-arg=-zmuldefs" cargo)
+export CARGOBUILD=rustc
 export CARGOFLAGS=
-TARGET=x86_64-unknown-redox
-REPO="$PWD/repo/$TARGET"
+export DEBUG=
+export EXAMPLES=
+export PREPARE_COPY=1
 
-set -e
+if hash sha256sum 2>/dev/null
+then
+    SHASUM="sha256sum"
+else
+    SHASUM="shasum -a 256"
+fi
+
+function usage {
+    echo "cook.sh $1 <op>" >&2
+    echo "  dist" >&2
+    echo "  distclean" >&2
+    echo "  build" >&2
+    echo "  clean" >&2
+    echo "  fetch" >&2
+    echo "  unfetch" >&2
+    echo "  pkg" >&2
+    echo "  unpkg" >&2
+    echo "  prepare" >&2
+    echo "  unprepare" >&2
+    echo "  stage" >&2
+    echo "  unstage" >&2
+    echo "  version" >&2
+}
 
 function op {
-    echo "$1" "$2"
+    if [ ! "$COOK_QUIET" = "1" ]
+    then
+        echo -e "\033[01;38;5;215mcook - $1 $2\033[0m" >&2
+    fi
+
     case "$2" in
+        dist)
+            op $1 prepare
+            op $1 build
+            op $1 stage
+            op $1 pkg
+            ;;
+        distclean)
+            op $1 unpkg
+            op $1 unstage
+            op $1 unprepare
+            ;;
         fetch)
-            if [ ! -d build ]
+            skip=0
+            if [ "$(type -t recipe_fetch)" = "function" ]
             then
-                git clone --recursive "$GIT" build
+                recipe_fetch
             fi
+            if [ "$skip" -eq "0" ]
+            then
+                if [ -n "$TAR" ]
+                then
+                    if [ ! -f source.tar ]
+                    then
+                        wget "$TAR" --continue -O source.tar.tmp
+                        mv source.tar.tmp source.tar
+                    fi
 
-            pushd build > /dev/null
-            git pull
-            git submodule sync
-            git submodule update --init --recursive
-            popd > /dev/null
+                    if [ -n "$TAR_SHA256" ]
+                    then
+                        $SHASUM -c <<< "${TAR_SHA256} source.tar"
+                    fi
+
+                    if [ ! -d source ]
+                    then
+                        mkdir source
+                        tar xvf source.tar -C source --strip-components 1
+                    fi
+                elif [ -n "$GIT" ]
+                then
+                    if [ ! -d source ]
+                    then
+                        if [ -n "$BRANCH" ]
+                        then
+                            git clone --recursive "$GIT" -b "$BRANCH" source
+                        else
+                            git clone --recursive "$GIT" source
+                        fi
+                    fi
+
+                    pushd source > /dev/null
+                    git remote set-url origin "$GIT"
+                    git fetch origin
+                    if [ -n "$GIT_UPSTREAM" ]
+                    then
+                        git remote set-url upstream "$GIT_UPSTREAM" &> /dev/null ||
+                        git remote add upstream "$GIT_UPSTREAM"
+                        git fetch upstream
+                    fi
+
+                    ORIGIN_BRANCH="$(git branch --remotes | grep '^  origin/HEAD -> ' | cut -d ' ' -f 5-)"
+                    if [ -n "$BRANCH" ]
+                    then
+                        ORIGIN_BRANCH="origin/$BRANCH"
+                    fi
+
+                    if [ "$(git rev-parse HEAD)" != "$(git rev-parse $ORIGIN_BRANCH)" ]
+                    then
+                        git checkout -B "$(echo "$ORIGIN_BRANCH" | cut -d / -f 2-)" "$ORIGIN_BRANCH"
+                    fi
+                    git submodule sync --recursive
+                    git submodule update --init --recursive
+                    popd > /dev/null
+                fi
+            fi
             ;;
         unfetch)
-            rm -rfv build
+            rm -rfv source source.tar
             ;;
-        update)
-            pushd build > /dev/null
-            xargo update
+        prepare)
+            skip=0
+            if [ "$(type -t recipe_prepare)" = "function" ]
+            then
+                recipe_prepare
+            fi
+            if [ "$skip" -eq "0" ]
+            then
+                rm -rf "${COOKBOOK_SYSROOT}"
+                mkdir "${COOKBOOK_SYSROOT}"
+
+                # usrmerge
+                mkdir "${COOKBOOK_SYSROOT}/usr"
+                for folder in bin include lib share
+                do
+                    mkdir "${COOKBOOK_SYSROOT}/usr/${folder}"
+                    ln -s "usr/${folder}" "${COOKBOOK_SYSROOT}/${folder}"
+                done
+
+                if [ ${#BUILD_DEPENDS} -gt 0 ]
+                then
+                    pushd $ROOT
+                        ./repo.sh "${BUILD_DEPENDS[@]}"
+                    popd
+
+                    for i in "${BUILD_DEPENDS[@]}"
+                    do
+                        pkgar \
+                            extract \
+                            "${COOKBOOK_SYSROOT}" \
+                            --archive "$REPO/$i.pkgar" \
+                            --pkey "${ROOT}/build/id_ed25519.pub.toml"
+                    done
+                fi
+
+                rm -rf "${COOKBOOK_BUILD}"
+                if [ "$PREPARE_COPY" -eq "0" ]
+                then
+                    mkdir "${COOKBOOK_BUILD}"
+                else
+                    cp -Rp source "${COOKBOOK_BUILD}"
+                fi
+
+                for patch in *.patch
+                do
+                    patch -p1 -d "${COOKBOOK_BUILD}" < "$patch"
+                done
+            fi
+            ;;
+        unprepare)
+            rm -rf "${COOKBOOK_BUILD}"
+            rm -rf "${COOKBOOK_SYSROOT}"
+            ;;
+        version)
+            pushd "${COOKBOOK_BUILD}" > /dev/null
+            skip=0
+            if [ "$(type -t recipe_version)" = "function" ]
+            then
+                recipe_version
+            fi
+            if [ "$skip" -eq "0" ]
+            then
+                # there's an unstable built-in cargo config command, so hack around it
+                cargo-config config package.version | tr -d '"'
+            fi
             popd > /dev/null
             ;;
+        gitversion)
+            if [ -d "${COOKBOOK_BUILD}"/.git ]
+            then
+                echo "$(op $1 version)-$(git -C "${COOKBOOK_BUILD}" rev-parse --short HEAD)"
+            else
+                op $1 version
+            fi
+            ;;
         build)
-            pushd build > /dev/null
-            xargo build --target "$TARGET" --release $CARGOFLAGS
+            pushd "${COOKBOOK_BUILD}" > /dev/null
+            skip=0
+            if [ "$(type -t recipe_build)" = "function" ]
+            then
+                recipe_build
+            fi
+
+            release_flag="--release"
+            if [ "$DEBUG" == 1 ]
+            then
+                release_flag=
+            fi
+
+            if [ -n "$CARGO_PACKAGE" ]; then
+                package_flag="--package=$CARGO_PACKAGE"
+            else
+                package_flag=
+            fi
+
+            if [ "$skip" -eq "0" ]
+            then
+                "${CARGO[@]}" "$CARGOBUILD" --target "$TARGET" $release_flag $package_flag $CARGOFLAGS
+            fi
             popd > /dev/null
             ;;
         clean)
-            pushd build > /dev/null
-            xargo clean
+            pushd "${COOKBOOK_BUILD}" > /dev/null
+            skip=0
+            if [ "$(type -t recipe_clean)" = "function" ]
+            then
+                recipe_clean
+            fi
+            if [ "$skip" -eq "0" ]
+            then
+                "${CARGO[@]}" clean
+            fi
             popd > /dev/null
             ;;
         stage)
-            mkdir -p stage
-            pushd build > /dev/null
+            op $1 unstage
+            mkdir -p "${COOKBOOK_STAGE}"
+            stage="$(realpath "${COOKBOOK_STAGE}")"
+            source="$(realpath source)"
+            pushd "${COOKBOOK_BUILD}" > /dev/null
+            skip=0
             if [ "$(type -t recipe_stage)" = "function" ]
             then
-                recipe_stage ../stage
+                recipe_stage "$stage"
             fi
-            #TODO xargo install --root "../stage" $CARGOFLAGS
-            bins="$(find target/x86_64-unknown-redox/release/ -maxdepth 1 -type f ! -name '*.*')"
-            if [ -n "$bins" ]
+            if [ "$skip" -eq "0" ]
             then
-                mkdir -p ../stage/bin
-                for bin in $bins
-                do
-                    cp -v "$bin" "../stage/bin/$(basename $bin)"
-                    strip -v "../stage/bin/$(basename $bin)"
-                done
+                #TODO "${CARGO[@]}" install --root "$stage" $CARGOFLAGS
+                if [ "$DEBUG" == 1 ]
+                then
+                    build=debug
+                else
+                    build=release
+                fi
+
+                bins="$(find target/$TARGET/$build/ -maxdepth 1 -type f ! -name '*.*')"
+                if [ -z "$bins" ] || [ "$EXAMPLES" == 1 ]
+                then
+                    example=true
+                    bins="$bins $(find target/$TARGET/$build/examples/ -maxdepth 1 -type f ! -name '*.*' ! -name '*-*' \
+                            2> /dev/null || true)"
+                fi
+                if [ -n "$bins" ]
+                then
+                    if [ -n "$example" ] && [ "$EXAMPLES" != 1 ]
+                    then
+                        echo "$(tput bold)Note$(tput sgr0): No binaries detected, using example binaries"
+                    fi
+                    mkdir -p "$stage/$BINDIR"
+                    for bin in $bins
+                    do
+                        if [ "$DEBUG" == 1 ]
+                        then
+                            cp -v "$bin" "$stage/$BINDIR/$(basename $bin)"
+                        else
+                            "${STRIP}" -v "$bin" -o "$stage/$BINDIR/$(basename $bin)"
+                        fi
+                    done
+                else
+                    echo "$(tput bold)Warning$(tput sgr0): Recipe does not have any binaries" >&2
+                fi
+
+                docgen "$source" "$stage/ref"
             fi
             popd > /dev/null
             ;;
         unstage)
-            rm -rfv stage
-            ;;
-        tar)
-            pushd stage > /dev/null
-            tar cfv ../stage.tar .
-            popd > /dev/null
-            ;;
-        untar)
-            rm -rfv stage.tar
+            rm -rfv "${COOKBOOK_STAGE}"
             ;;
-        publish)
-            mkdir -p "$REPO"
-            cp -v stage.tar "$REPO/$1.tar"
+        pkg)
+            pkgar \
+                create \
+                --archive "${COOKBOOK_STAGE}.pkgar" \
+                --skey "${ROOT}/build/id_ed25519.toml" \
+                "${COOKBOOK_STAGE}"
+
+            # Generate stage.toml
+            echo "name = \"$1\"" > "${COOKBOOK_STAGE}.toml"
+            echo "version = \"$(op $1 version)\"" >> "${COOKBOOK_STAGE}.toml"
+            echo "target = \"$TARGET\"" >> "${COOKBOOK_STAGE}.toml"
+
+            # Add runtime dependencies to package if they exist
+            if [ -n "$DEPENDS" ]
+            then
+                # Remove leading and trailing whitespace, replace whitespace between
+                # package names with commas, and surround package names with quotes
+                dependencies=$(echo -e "$DEPENDS" | sed -E 's/^[[:space:]]*//;s/[[:space:]]*$//;s/[[:space:]]+/,/g;s/[^, ][^, ]*/"&"/g')
+                echo "depends = [$dependencies]" >> "${COOKBOOK_STAGE}.toml"
+            else
+                echo "depends = []" >> "${COOKBOOK_STAGE}.toml"
+            fi
             ;;
-        unpublish)
-            rm -rfv "$REPO/$1.tar"
+        unpkg)
+            rm -fv "${COOKBOOK_STAGE}.pkgar" "${COOKBOOK_STAGE}.toml"
             ;;
         *)
-            echo "cook.sh $1 {build|clean|fetch|unfetch|publish|unpublish|stage|unstage|tar|untar|update}"
+            usage $1
             ;;
     esac
 }
 
 if [ -n "$1" ]
 then
-    if [ -d "recipes/$1" ]
+    if (echo "$1" | grep '.*/.*' >/dev/null); then
+        recipe_name=$(basename "$1")
+        recipe_path="recipes/$1"
+    else
+        recipe_name="$1"
+        recipe_path=`target/release/find_recipe $recipe_name`
+    fi
+
+    if [ -d "$ROOT/$recipe_path" ]
     then
-        cd "recipes/$1"
-        source recipe.sh
+        export COOKBOOK_RECIPE="${ROOT}/$recipe_path"
+
+        TARGET_DIR="${COOKBOOK_RECIPE}/target/${TARGET}"
+        mkdir -p "${TARGET_DIR}"
+
+        export COOKBOOK_BUILD="${TARGET_DIR}/build"
+        export COOKBOOK_STAGE="${TARGET_DIR}/stage"
+        export COOKBOOK_SOURCE="${COOKBOOK_RECIPE}/source"
+        export COOKBOOK_SYSROOT="${TARGET_DIR}/sysroot"
+
+        export PKG_CONFIG_ALLOW_CROSS=1
+        export PKG_CONFIG_PATH=
+        export PKG_CONFIG_LIBDIR="${COOKBOOK_SYSROOT}/lib/pkgconfig"
+        export PKG_CONFIG_SYSROOT_DIR="${COOKBOOK_SYSROOT}"
+
+        cd "${COOKBOOK_RECIPE}"
+
+        if [ -e recipe.sh ]; then
+            source recipe.sh
+        fi
+
+        ops=()
         for arg in "${@:2}"
         do
-            op "$1" "$arg"
+            if [ "$arg" == "--debug" ]
+            then
+                DEBUG=1
+            else
+                ops[${#ops[@]}]="$arg"
+            fi
+        done
+
+        for i in "${ops[@]}"
+        do
+            op "$recipe_name" "$i"
         done
     else
-        echo "cook.sh: recipe '$1' not found"
+        echo "cook.sh: recipe '$recipe_name' at not found" >&2
+        exit 1
     fi
 else
-    echo "cook.sh {package} {build|clean|fetch|unfetch|publish|unpublish|stage|unstage|tar|untar|update}"
+    usage "{package}"
 fi

docgen @ c9525c47

+Subproject commit c9525c4761d814b86af061e4e96cd394da7deaa2

fetch.sh

+#!/usr/bin/env bash
+set -e
+
+source config.sh
+
+if [ $# = 0 ]
+then
+    recipes="$(target/release/list_recipes)"
+else
+    recipes="$@"
+fi
+
+for recipe_path in $recipes
+do
+    if (echo "$recipe_path" | grep '.*/.*' >/dev/null); then
+        recipe_name=$(basename "$recipe_path")
+        recipe_path="recipes/$recipe_path"
+    else
+        recipe_name="$recipe_path"
+        recipe_path=`target/release/find_recipe $recipe_name`
+    fi
+
+    if [ -e "$recipe_path/recipe.toml" ]
+    then
+        target/release/cook --fetch-only "$recipe_name"
+    else
+        ./cook.sh "$recipe_name" fetch
+    fi
+done

jenkins.sh

-export PATH="$HOME/.cargo/bin:$PATH"
-./all.sh untar unstage fetch build stage tar publish

pkgar @ 0ccbc991

+Subproject commit 0ccbc9914b1ec655e23d4babc5afed87e42e9a0f

recipes/acid/recipe.sh

-GIT=https://github.com/redox-os/acid.git