Fix build error with --build-template conda/micromamba:v2 for singularity (#972)

Signed-off-by: munishchouhan <hrma017@gmail.com>
Signed-off-by: Paolo Di Tommaso <paolo.ditommaso@gmail.com>
Co-authored-by: Paolo Di Tommaso <paolo.ditommaso@gmail.com>

Author: munishchouhan

docs/api.md

@@ -218,12 +218,12 @@ Returns the name of the container request made available by Wave.
 | `mambaImage`                        | Name of the Docker image used to build Conda containers.                                                                                              |
 | `commands`                          | Command to be included in the container.                                                                                                                       |
 | `basePackages`                      | Names of base packages.                                                                                                                                        |
-| `baseImage`                         | Base image for the final stage of multi-stage Conda/Pixi builds.                                                                                        |
+| `baseImage`                         | Base image for the final stage of multi-stage Conda/Pixi Docker builds. Has no effect on Singularity builds.                                            |
 | `pixiOpts`                          | Pixi build options (when `type` is `CONDA` and `buildTemplate` is `conda/pixi:v1`).                                                                                  |
 | `pixiImage`                         | Name of the Docker image used for Pixi package manager (e.g., `ghcr.io/prefix-dev/pixi:latest`).                                                              |
 | `cranOpts`                          | CRAN build options (when `type` is `CRAN`).                                                                                                                        |
 | `rImage`                            | Name of the R Docker image used to build CRAN containers (e.g., `rocker/r-ver:4.4.1`).                                                                         |
-| `buildTemplate`                     | The build template to use for container builds. Supported values: `conda/pixi:v1` (Pixi with multi-stage builds), `conda/micromamba:v2` (Micromamba 2.x with multi-stage builds). Default: `conda/micromamba:v1` template. |
+| `buildTemplate`                     | The build template to use for container builds. Supported values: `conda/pixi:v1` (multi-stage build using Pixi), `conda/micromamba:v2` (multi-stage build using Micromamba 2.x). Both produce smaller images by excluding the package manager from the final stage (Singularity still uses a single-stage build). Default: `conda/micromamba:v1`. |
 | `nameStrategy`                      | The name strategy to be used to create the name of the container built by Wave. Options: `none`, `tagPrefix`, `imageSuffix`.                       |                                                     |
 
 #### Response
@@ -493,7 +493,7 @@ Get status of build against `buildId` passed as path variable
     }
     ```
 
-- Create Singularity image with Pixi v1 template (multi-stage build):
+- Create Singularity image with Pixi v1 template (single-stage build):
 
     **Request**
 
@@ -535,7 +535,7 @@ Get status of build against `buildId` passed as path variable
     }
     ```
 
-- Create Singularity image with Micromamba v2 template (multi-stage build):
+- Create Singularity image with Micromamba v2 template (single-stage build):
 
     **Request**
 
@@ -578,19 +578,15 @@ Get status of build against `buildId` passed as path variable
     ```
 
 :::note
-Multi-stage build templates (`conda/pixi:v1` and `conda/micromamba:v2`) create optimized container images by separating the build environment from the final runtime environment. This results in smaller container images that only contain the installed packages and runtime dependencies, without the build tools.
+Multi-stage build templates (`conda/pixi:v1` and `conda/micromamba:v2`) create optimized Docker container images by separating the build environment from the final runtime environment. This results in smaller container images that only contain the installed packages and runtime dependencies, without the build tools.
 :::
 
 :::important
-**Image Requirements for Singularity Builds with Pixi and Micromamba v2 Templates**
+**Singularity builds use single-stage**
 
-When building Singularity images (`format: "sif"`) with the `conda/pixi:v1` or `conda/micromamba:v2` build templates, base images (via `baseImage` option) must have the `tar` utility installed.
+When building Singularity images (`format: "sif"`) with the `conda/pixi:v1` or `conda/micromamba:v2` build templates, single-stage builds are used. Singularity's proot-based builder cannot preserve file permissions when transferring files across stages, so the conda/pixi environment is installed directly in a single stage using the mamba/pixi image as the base.
 
-This requirement exists because Singularity's multi-stage builds use `proot` to emulate filesystem operations, which cannot reliably copy directory structures between build stages. The templates support this by compressing the environment into a tarball (`tar czf`) and extracting it (`tar xzf`) in the final stage.
-
-Docker builds are not affected by this requirement. Docker's native `COPY --from=build` directive handles directory copying directly.
-
-Most standard base images (Ubuntu, Debian, Alpine, etc.) include `tar` by default, but minimal or distroless images may require explicit installation.
+As a result, the `baseImage` option has no effect on Singularity builds — it only applies to Docker builds. The multi-stage image size optimization is also not available for Singularity.
 :::
 
 ### GET `/v1alpha1/builds/{buildId}/status`

docs/cli/use-cases.md

@@ -93,8 +93,8 @@ The Wave CLI supports build templates for creating container images from Conda p
 | Template              | Description                                                                                                      |
 |-----------------------|------------------------------------------------------------------------------------------------------------------|
 | `conda/micromamba:v1` | Single-stage build using Micromamba v1 (default). The final image includes the package manager.                  |
-| `conda/micromamba:v2` | Multi-stage build using Micromamba 2.x. Produces smaller images without the package manager in the final stage.  |
-| `conda/pixi:v1`       | Multi-stage build using [Pixi][pixi] package manager. Produces smaller images with faster dependency resolution. |
+| `conda/micromamba:v2` | Multi-stage build using Micromamba 2.x. Produces smaller images by excluding the package manager from the final stage (Singularity still uses a single-stage build). |
+| `conda/pixi:v1`       | Multi-stage build using [Pixi][pixi] package manager. Produces smaller images with faster dependency resolution (Singularity still uses a single-stage build). |
 
 **Related CLI arguments**
 
@@ -110,11 +110,11 @@ Multi-stage build templates offer several advantages:
 - **Reproducibility**: Lock files are generated for exact package version tracking.
 - **Security**: Fewer binaries in the final image reduces the attack surface.
 
-**Singularity build requirements**
+**Singularity builds use single-stage**
 
-When building Singularity containers (`--singularity`) with the `conda/micromamba:v2` or `conda/pixi:v1` templates, base images must have the `tar` utility installed. This is required because Singularity's multi-stage builds use `proot`, which cannot copy directory structures directly between build stages. The templates work around this by compressing the environment with `tar` and extracting it in the final stage.
+When building Singularity containers (`--singularity`) with the `conda/micromamba:v2` or `conda/pixi:v1` templates, single-stage builds are used. Singularity's proot-based builder cannot preserve file permissions when transferring files across stages, so the conda/pixi environment is installed directly in a single stage using the mamba/pixi image as the base.
 
-Docker builds are not affected by this requirement.
+As a result, the `baseImage` option has no effect on Singularity builds — it only applies to Docker builds. The multi-stage image size optimization is also not available for Singularity.
 
 **Example usage**
 
@@ -126,7 +126,7 @@ wave \
   --build-template conda/pixi:v1
 ```
 
-Build a container using the Micromamba v2 multi-stage template:
+Build a container using the Micromamba v2 template:
 
 ```bash
 wave \

src/main/resources/templates/conda-micromamba-v2/singularityfile-conda-file.txt

@@ -1,6 +1,5 @@
 BootStrap: docker
 From: {{mamba_image}}
-Stage: build
 %files
     {{wave_context_dir}}/conda.yml /scratch/conda.yml
 %post
@@ -10,17 +9,6 @@ Stage: build
     echo ">> CONDA_LOCK_START"
     cat environment.lock
     echo "<< CONDA_LOCK_END"
-    tar czf /opt/conda.tar.gz -C /opt conda
-
-Bootstrap: docker
-From: {{base_image}}
-Stage: final
-%files from build
-    /opt/conda.tar.gz /opt/conda.tar.gz
-%post
-    cd /opt
-    tar xzf conda.tar.gz
-    rm conda.tar.gz
 %environment
     export MAMBA_ROOT_PREFIX=/opt/conda
     export PATH="$MAMBA_ROOT_PREFIX/bin:$PATH"

src/main/resources/templates/conda-micromamba-v2/singularityfile-conda-packages.txt

@@ -1,19 +1,12 @@
 BootStrap: docker
 From: {{mamba_image}}
-Stage: build
 %post
     micromamba install -y -n base {{channel_opts}} {{target}}
     {{base_packages}}
     micromamba env export --name base --explicit > environment.lock
     echo ">> CONDA_LOCK_START"
     cat environment.lock
     echo "<< CONDA_LOCK_END"
-
-Bootstrap: docker
-From: {{base_image}}
-Stage: final
-%files from build
-    /opt/conda /opt/conda
 %environment
     export MAMBA_ROOT_PREFIX=/opt/conda
     export PATH="$MAMBA_ROOT_PREFIX/bin:$PATH"

src/main/resources/templates/conda-pixi-v1/singularityfile-conda-file.txt

@@ -1,6 +1,5 @@
 BootStrap: docker
 From: {{pixi_image}}
-Stage: build
 %files
     {{wave_context_dir}}/conda.yml /scratch/conda.yml
 %post
@@ -12,19 +11,5 @@ Stage: build
     echo ">> CONDA_LOCK_START"
     cat /opt/wave/pixi.lock
     echo "<< CONDA_LOCK_END"
-    tar czf /opt/pixi-env.tar.gz -C /opt/wave/.pixi/envs default
-    ls -lh /opt/pixi-env.tar.gz
-
-Bootstrap: docker
-From: {{base_image}}
-Stage: final
-# install binary from stage one
-%files from build
-    /opt/pixi-env.tar.gz /opt/pixi-env.tar.gz
-    /shell-hook.sh /shell-hook.sh
-%post
-    mkdir -p /opt/wave/.pixi/envs
-    tar xzf /opt/pixi-env.tar.gz -C /opt/wave/.pixi/envs
-    rm /opt/pixi-env.tar.gz
 %environment
     export PATH="$MAMBA_ROOT_PREFIX/bin:$PATH"

src/test/groovy/io/seqera/wave/util/CondaHelperTest.groovy

@@ -168,10 +168,10 @@ class CondaHelperTest extends Specification {
         then:
         result.contains('BootStrap: docker')
         result.contains('From: mambaorg/micromamba:2-amazon2023')
-        result.contains('Stage: build')
         result.contains('micromamba install -y -n base -f /scratch/conda.yml')
-        result.contains('Bootstrap: docker')
-        result.contains('From: ubuntu:24.04')
+        result.contains('%files')
+        result.contains('%post')
+        result.contains('%environment')
     }
 
     def 'should create v2 docker file with lock file'() {

src/test/groovy/io/seqera/wave/util/PixiHelperTest.groovy

@@ -63,12 +63,11 @@ class PixiHelperTest extends Specification {
         then:
         result.contains('BootStrap: docker')
         result.contains('From: public.cr.seqera.io/wave/pixi:0.61.0-noble')
-        result.contains('Stage: build')
         result.contains('pixi init --import /scratch/conda.yml')
         result.contains('pixi shell-hook > /shell-hook.sh')
-        result.contains('Bootstrap: docker')
-        result.contains('From: ubuntu:24.04')
-        result.contains('Stage: final')
+        result.contains('%files')
+        result.contains('%post')
+        result.contains('%environment')
     }
 
     def 'should use custom base image'() {