Add multi-arch support to yarn buildpack: update publish.sh, package.sh, build.sh to read targets from buildpack.toml, add yj support, and update README with packaging/publishing instructions

Author: vishal24367

README.md

@@ -46,14 +46,16 @@ file that looks like the following:
     launch = true
 ```
 
-## Usage
+## Packaging
 
 To package this buildpack for consumption:
 
-```shell
-$ ./scripts/package.sh --version <version-number>
+```bash
+./scripts/package.sh --version 2.2.6
 ```
 
+This will build the buildpack for all target architectures specified in `buildpack.toml` (amd64 and arm64 by default) and create a single archive containing binaries for all architectures in the `build/` directory.
+
 This will create a `buildpackage.cnb` file under the `build` directory which you
 can use to build your app as follows:
 ```shell
@@ -66,6 +68,29 @@ pack build <app-name> \
 
 Though the API of this buildpack does not require `node`, yarn is unusable without node.
 
+## Publishing
+
+To publish this buildpack to ECR:
+
+```bash
+# First, authenticate with ECR (if not already authenticated)
+aws ecr get-login-password --region us-east-1 | \
+  docker login --username AWS --password-stdin 348674388966.dkr.ecr.us-east-1.amazonaws.com
+
+# Then publish the buildpack
+./scripts/publish.sh \
+  --image-ref 348674388966.dkr.ecr.us-east-1.amazonaws.com/neeto-deploy/paketo/buildpack/yarn:<version> \
+  --buildpack-type buildpack
+```
+
+The script will automatically:
+- Read target architectures from `buildpack.toml`
+- Extract the buildpack archive
+- Publish each architecture separately with arch-suffixed tags (e.g., `yarn:<version>-amd64`, `yarn:<version>-arm64`)
+- Create and push a multi-arch manifest list
+
+## Usage
+
 ## Run Tests
 
 To run all unit tests, run:

buildpack.toml

@@ -5,6 +5,7 @@ api = "0.7"
   id = "neeto-deploy/yarn"
   name = "Paketo Buildpack for Yarn"
   sbom-formats = ["application/vnd.cyclonedx+json", "application/spdx+json", "application/vnd.syft+json"]
+  version = "2.2.6"
 
   [[buildpack.licenses]]
     type = "Apache-2.0"
@@ -21,7 +22,7 @@ api = "0.7"
     "linux/arm64/bin/run",
   ]
 
-  pre-package = "./scripts/build.sh --target linux/amd64 --target linux/arm64"
+  pre-package = "./scripts/build.sh"
 
   [metadata.default_versions]
     yarn = "1.*"

neeto-deploy-paketo-yarn-start-buildpack

@@ -0,0 +1 @@
+Subproject commit c8afb63c824c616b09bec074b678209c4dc4951f

scripts/.util/tools.json

@@ -2,5 +2,6 @@
   "createpackage": "v1.73.0",
   "jam": "v2.15.1",
   "libpaktools": "v0.3.0",
-  "pack": "v0.38.2"
+  "pack": "v0.38.2",
+  "yj": "v5.1.0"
 }

scripts/.util/tools.sh

@@ -283,6 +283,60 @@ function util::tools::create-package::install () {
     fi
 }
 
+function util::tools::yj::install() {
+  local dir token
+  token=""
+
+  while [[ "${#}" != 0 ]]; do
+    case "${1}" in
+      --directory)
+        dir="${2}"
+        shift 2
+        ;;
+
+      --token)
+        token="${2}"
+        shift 2
+        ;;
+
+      *)
+        util::print::error "unknown argument \"${1}\""
+    esac
+  done
+
+  mkdir -p "${dir}"
+  util::tools::path::export "${dir}"
+
+  if [[ ! -f "${dir}/yj" ]]; then
+    local version curl_args os arch
+
+    version="$(jq -r .yj "$(dirname "${BASH_SOURCE[0]}")/tools.json")"
+
+    curl_args=(
+      "--fail"
+      "--silent"
+      "--location"
+      "--output" "${dir}/yj"
+    )
+
+    if [[ "${token}" != "" ]]; then
+      curl_args+=("--header" "Authorization: Token ${token}")
+    fi
+
+    util::print::title "Installing yj ${version}"
+
+    os=$(util::tools::os macos)
+    arch=$(util::tools::arch)
+
+    curl "https://github.com/sclevine/yj/releases/download/${version}/yj-${os}-${arch}" \
+      "${curl_args[@]}"
+
+    chmod +x "${dir}/yj"
+  else
+    util::print::info "Using yj $("${dir}"/yj -v 2>&1 || echo "unknown version")"
+  fi
+}
+
 function util::tools::tests::checkfocus() {
   testout="${1}"
   if grep -q 'Focused: [1-9]' "${testout}"; then

scripts/build.sh

@@ -37,9 +37,31 @@ function main() {
 
   mkdir -p "${BUILDPACKDIR}/bin"
 
+  # Read targets from buildpack.toml if no targets provided via flags
+  if [[ ${#targets[@]} -eq 0 ]]; then
+    local buildpack_toml="${BUILDPACKDIR}/buildpack.toml"
+    if [[ -f "${buildpack_toml}" ]]; then
+      util::print::info "Reading targets from ${buildpack_toml}..."
+      # Check if yj and jq are available
+      if command -v yj >/dev/null 2>&1 && command -v jq >/dev/null 2>&1; then
+        local targets_json
+        targets_json=$(cat "${buildpack_toml}" | yj -tj | jq -r '.targets[]? | "\(.os)/\(.arch)"' 2>/dev/null || echo "")
+        while IFS= read -r target; do
+          if [[ -n "${target}" ]]; then
+            targets+=("${target}")
+          fi
+        done <<< "${targets_json}"
+        if [[ ${#targets[@]} -gt 0 ]]; then
+          util::print::info "Found ${#targets[@]} target(s) in buildpack.toml: ${targets[*]}"
+        fi
+      fi
+    fi
+    
+    # Fallback to default if still no targets
   if [[ ${#targets[@]} -eq 0 ]]; then
     targets=("linux/amd64")
-    util::print::info "Setting default target platform architecture to: linux/amd64"
+      util::print::info "No targets found in buildpack.toml. Setting default target platform architecture to: linux/amd64"
+    fi
   fi
 
   run::build
@@ -61,6 +83,7 @@ OPTIONS
   --target strings  Target platforms to build for.
                     Targets should be in the format '[os][/arch][/variant]'.
                       - To specify two different architectures: '--target "linux/amd64" --target "linux/arm64"'
+                    If not provided, targets will be read from buildpack.toml
   --help  -h        prints the command usage
 USAGE
 }

scripts/package.sh

@@ -76,6 +76,26 @@ function main {
     buildpack_type=extension
   fi
 
+  # Read targets from buildpack.toml if no targets provided via flags
+  if [[ ${#targets[@]} -eq 0 ]]; then
+    local buildpack_toml="${ROOT_DIR}/buildpack.toml"
+    if [[ -f "${buildpack_toml}" ]]; then
+      util::print::info "Reading targets from ${buildpack_toml}..."
+      if command -v yj >/dev/null 2>&1 && command -v jq >/dev/null 2>&1; then
+        local targets_json
+        targets_json=$(cat "${buildpack_toml}" | yj -tj | jq -r '.targets[]? | "\(.os)/\(.arch)"' 2>/dev/null || echo "")
+        while IFS= read -r target; do
+          if [[ -n "${target}" ]]; then
+            targets+=("${target}")
+          fi
+        done <<< "${targets_json}"
+        if [[ ${#targets[@]} -gt 0 ]]; then
+          util::print::info "Found ${#targets[@]} target(s) in buildpack.toml: ${targets[*]}"
+        fi
+      fi
+    fi
+  fi
+
   buildpack::archive "${version}" "${buildpack_type}"
   if [[ ${#targets[@]} -gt 0 ]]; then
     buildpackage::create "${output}" "${buildpack_type}" "${targets[@]}"
@@ -95,7 +115,7 @@ OPTIONS
   --version <version>  -v <version>  specifies the version number to use when packaging a buildpack or an extension
   --output <output>    -o <output>   location to output the packaged buildpackage or extension artifact (default: ${ROOT_DIR}/build/buildpackage.cnb)
   --token <token>                    Token used to download assets from GitHub (e.g. jam, pack, etc) (optional)
-  --target <target>                  Target platform (e.g. linux/amd64). Can be specified multiple times for multi-arch (optional)
+  --target <target>                  Target platform (e.g. linux/amd64). Can be specified multiple times for multi-arch (optional). If not provided, targets will be read from buildpack.toml
 USAGE
 }
 
@@ -118,6 +138,10 @@ function tools::install() {
     --directory "${BIN_DIR}" \
     --token "${token}"
 
+  util::tools::yj::install \
+    --directory "${BIN_DIR}" \
+    --token "${token}"
+
   if [[ -f "${ROOT_DIR}/.libbuildpack" ]]; then
     util::tools::packager::install \
       --directory "${BIN_DIR}"

scripts/publish.sh

@@ -113,30 +113,111 @@ function tools::install() {
   util::tools::pack::install \
     --directory "${BIN_DIR}" \
     --token "${token}"
+
+  util::tools::yj::install \
+    --directory "${BIN_DIR}" \
+    --token "${token}"
 }
 
 function buildpack::publish() {
-
   local image_ref buildpack_type archive_path
   image_ref="${1}"
   buildpack_type="${2}"
   archive_path="${3}"
 
   util::print::title "Publishing ${buildpack_type}..."
 
-  util::print::info "Extracting archive..."
-  tmp_dir=$(mktemp -d -p $ROOT_DIR)
-  tar -xvf $archive_path -C $tmp_dir
+  # Read targets from buildpack.toml
+  local buildpack_toml="${ROOT_DIR}/buildpack.toml"
+  local -a targets=()
+  
+  if [[ -f "${buildpack_toml}" ]]; then
+    util::print::info "Reading targets from ${buildpack_toml}..."
+    # Use yj and jq if available
+    if command -v yj >/dev/null 2>&1 && command -v jq >/dev/null 2>&1; then
+      local targets_json
+      targets_json=$(cat "${buildpack_toml}" | yj -tj | jq -r '.targets[]? | "\(.os)/\(.arch)"' 2>/dev/null || echo "")
+      while IFS= read -r target; do
+        if [[ -n "${target}" ]]; then
+          targets+=("${target}")
+        fi
+      done <<< "${targets_json}"
+    fi
+  fi
 
-  util::print::info "Publishing ${buildpack_type} to ${image_ref}"
+  if [[ ${#targets[@]} -gt 0 ]]; then
+    util::print::info "Found ${#targets[@]} target(s) in buildpack.toml: ${targets[*]}"
+  fi
 
-  pack \
-    ${buildpack_type} package $image_ref \
-    --path $tmp_dir \
-    --format image \
-    --publish
+  if [[ ! -f "${archive_path}" ]]; then
+    util::print::error "buildpack artifact not found at ${archive_path}; run scripts/package.sh first"
+  fi
 
-  rm -rf $tmp_dir
+  # For multi-arch, pack needs to publish each architecture separately, then create a manifest
+  if [[ ${#targets[@]} -gt 1 ]]; then
+    # Multi-arch publishing
+    util::print::info "Publishing multi-arch ${buildpack_type} (${#targets[@]} architectures)..."
+    
+    # Check if manifest list already exists and remove it
+    if docker manifest inspect "${image_ref}" >/dev/null 2>&1; then
+      util::print::info "Existing manifest list found for ${image_ref}. Removing it..."
+      docker manifest rm "${image_ref}"
+    fi
+    
+    # Extract archive once
+    local tmp_dir
+    tmp_dir=$(mktemp -d -p "${ROOT_DIR}")
+    tar -xzf "${archive_path}" -C "${tmp_dir}"
+    
+    local arch_images=()
+    for target in "${targets[@]}"; do
+      local arch
+      arch=$(echo "${target}" | cut -d'/' -f2)
+      local arch_image_ref="${image_ref}-${arch}"
+      
+      util::print::info "Publishing ${target} as ${arch_image_ref}..."
+      
+      pack \
+        ${buildpack_type} package "${arch_image_ref}" \
+        --path "${tmp_dir}" \
+        --target "${target}" \
+        --format image \
+        --publish
+      
+      arch_images+=("${arch_image_ref}")
+    done
+    
+    # Create multi-arch manifest
+    util::print::info "Creating multi-arch manifest for ${image_ref}..."
+    docker manifest create "${image_ref}" "${arch_images[@]}"
+    docker manifest push "${image_ref}"
+    
+    rm -rf "${tmp_dir}"
+    util::print::info "Successfully published multi-arch ${buildpack_type}: ${image_ref}"
+  else
+    # Single architecture or no targets detected
+    util::print::info "Extracting archive..."
+    local tmp_dir
+    tmp_dir=$(mktemp -d -p "${ROOT_DIR}")
+    tar -xzf "${archive_path}" -C "${tmp_dir}"
+
+    util::print::info "Publishing ${buildpack_type} to ${image_ref}"
+
+    local pack_args=(
+      ${buildpack_type} package "${image_ref}"
+      --path "${tmp_dir}"
+      --format image
+      --publish
+    )
+    
+    # Add target if we have one
+    if [[ ${#targets[@]} -eq 1 ]]; then
+      pack_args+=(--target "${targets[0]}")
+    fi
+
+    pack "${pack_args[@]}"
+    rm -rf "${tmp_dir}"
+  fi
 }
 
 main "${@:-}"