aws-lambda-layer-cli 2.0.4 → 2.2.0

package/README.md

@@ -4,10 +4,10 @@ A command-line tool for creating and publishing AWS Lambda layers for Node.js an
 
 ## Features
 
-- Create and publish Lambda layers for Node.js (npm) and Python (uv/pip)
-- Automatic version management and smart naming
-- Direct publishing to AWS with IAM credentials and region support
-- Support for multiple packages in a single layer
+- **Effortless Publishing**: Create and publish Node.js and Python layers in a single command
+- **Smart Compatibility**: Auto-selects the right Linux binaries for Amazon Linux 2 or 2023
+- **Cross-Architecture**: Native support for `x86_64` and `arm64` builds
+- **Auto-Versioning**: Automatically handles layer naming and version increments
 
 ## Installation
 
@@ -46,13 +46,14 @@ aws-lambda-layer-cli <command> [options]
 |--------|-------------|
 | `--nodejs, -n <pkgs>` | Create Node.js layer (comma-separated packages) |
 | `--python, -p <pkgs>` | Create Python layer (comma-separated packages) |
+| `--wheel, -w <file>`  | Use with `--python` to create layer from `.whl` file |
 | `--name` | Custom layer name |
 | `--description` | Layer description (publish only) |
 | `--profile` | AWS CLI profile (publish only) |
 | `--region` | AWS region (publish only) |
+| `--architecture, -a` | Target architecture (`x86_64` or `arm64`) |
 | `--node-version` | Node.js version (default: 24) |
 | `--python-version` | Python version (default: 3.14) |
-| `--no-uv` | Use pip/venv instead of uv |
 | `-v, --version` | Show version |
 
 ## Examples
@@ -68,12 +69,26 @@ aws-lambda-layer-cli publish --nodejs lodash --profile prod --region us-east-1 -
 
 ### Python
 ```bash
-# Create local zip with specific python version
-aws-lambda-layer-cli zip --python numpy==1.26.0,pandas --python-version 3.12
+# Create local zip with specific python version and architecture
+aws-lambda-layer-cli zip --python numpy==1.26.0,pandas --python-version 3.12 --architecture arm64
 
-# Publish to AWS
-aws-lambda-layer-cli publish --python requests --name web-layer
+# Publish to AWS for ARM64 architecture
+aws-lambda-layer-cli publish --python requests --name web-layer --architecture arm64
 ```
+> **Note**: This tool automatically selects the optimal platform based on the Python version:
+> - **Python 3.12+ (Amazon Linux 2023)**: Targets `manylinux_2_28` (GLIBC 2.28+)
+> - **Python 3.11- (Amazon Linux 2)**: Targets `manylinux2014` (GLIBC 2.17+)
+
+### Wheel File
+The tool auto-detects Python version and architecture from the wheel filename.
+```bash
+# Create local zip from wheel (preferred syntax)
+aws-lambda-layer-cli zip --python --wheel numpy-2.4.1-cp313-cp313-manylinux.whl
+
+# Publish directly from wheel
+aws-lambda-layer-cli publish --python --wheel pandas-2.1.0-cp311-...-x86_64.whl
+```
+> **Note**: For wheels, arguments like `--python-version` or `--architecture` are checked against the wheel metadata. If they conflict, the tool will error to prevent incompatibility.
 
 ## Shell Completion
 

package/completion/aws-lambda-layer-completion.bash

@@ -13,7 +13,7 @@ _aws_lambda_layer_cli() {
     local common_opts="--name -h --help"
     local publish_opts="--description --layer-name --profile --region"
     local node_opts="--node-version"
-    local python_opts="--python-version --no-uv"
+    local python_opts="--python-version --platform"
 
     case ${cword} in
         1)

package/completion/aws-lambda-layer-completion.zsh

@@ -40,7 +40,7 @@ _aws-lambda-layer-cli() {
     
     python_opts=(
         '--python-version:version:'
-        '--no-uv'
+        '--platform:platform:'
     )
     
     _arguments -C \

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aws-lambda-layer-cli",
-  "version": "2.0.4",
+  "version": "2.2.0",
   "description": "CLI tool for creating and publishing AWS Lambda layers for Node.js and Python.",
   "keywords": [
     "aws",

package/scripts/aws-lambda-layer-cli

@@ -41,13 +41,19 @@ else
     PYTHON_SCRIPT="$INSTALL_DIR/create_python_layer.sh"
 fi
 
+if [ -f "$SCRIPT_DIR/create_wheel_layer.sh" ]; then
+    WHEEL_SCRIPT="$SCRIPT_DIR/create_wheel_layer.sh"
+else
+    WHEEL_SCRIPT="$INSTALL_DIR/create_wheel_layer.sh"
+fi
+
 BIN_DIR="/usr/local/bin"
 COMPLETION_DIR="/etc/bash_completion.d"
 
 # Show help
 show_help() {
     local version_file="$SCRIPT_DIR/VERSION.txt"
-    local version="2.0.4"
+    local version="2.2.0"
     if [ -f "$version_file" ]; then
         version=$(cat "$version_file")
     fi
@@ -56,8 +62,10 @@ show_help() {
     printf "${BLUE}Usage:${NC}\n"
     printf "  aws-lambda-layer-cli ${GREEN}zip${NC} ${YELLOW}--nodejs${NC} <packages> [options]\n"
     printf "  aws-lambda-layer-cli ${GREEN}zip${NC} ${YELLOW}--python${NC} <packages> [options]\n"
+    printf "  aws-lambda-layer-cli ${GREEN}zip${NC} ${YELLOW}--python --wheel${NC} <wheel_file> [options]\n"
     printf "  aws-lambda-layer-cli ${GREEN}publish${NC} ${YELLOW}--nodejs${NC} <packages> [options]\n"
     printf "  aws-lambda-layer-cli ${GREEN}publish${NC} ${YELLOW}--python${NC} <packages> [options]\n"
+    printf "  aws-lambda-layer-cli ${GREEN}publish${NC} ${YELLOW}--python --wheel${NC} <wheel_file> [options]\n"
     printf "  aws-lambda-layer-cli ${GREEN}help${NC}\n"
     printf "  aws-lambda-layer-cli [options]\n\n"
     
@@ -72,8 +80,11 @@ show_help() {
     printf "  ${YELLOW}--nodejs, --node, -n${NC}    Create a Node.js Lambda layer\n"
     printf "  ${YELLOW}--python, --py, -p${NC}      Create a Python Lambda layer\n"
     printf "  ${YELLOW}--runtime=RUNTIME${NC}       Specify runtime (nodejs or python)\n"
+    printf "${BLUE}Source Options (Python only):${NC}\n"
+    printf "  ${YELLOW}--wheel, -w${NC}             Create layer from existing Wheel file\n"
     printf "${BLUE}Arguments:${NC}\n"
-    printf "  <packages>              Comma-separated list of packages with optional versions (required)\n"
+    printf "  <packages>              Comma-separated list of packages\n"
+    printf "  <wheel_file>            Path to a local .whl file (use with --python --wheel)\n"
 
     printf "${BLUE}Common Options:${NC}\n"
     printf "  ${YELLOW}--name${NC}                  Name for the output zip file / layer name\n"
@@ -85,7 +96,7 @@ show_help() {
     printf "  ${YELLOW}--version, -v${NC}           Show tool version information\n"
     printf "  ${YELLOW}--node-version${NC}          Node.js version (default: 24)\n"
     printf "  ${YELLOW}--python-version${NC}        Python version (default: 3.14)\n"
-    printf "  ${YELLOW}--no-uv${NC}                 Use pip/venv instead of uv\n\n"
+    printf "  ${YELLOW}--architecture, -a${NC}      Target architecture (x86_64, arm64)\n\n"
     
     printf "${MAGENTA}${UNDERLINE}Package Version Examples:${NC}\n"
     printf "  Node.js:    express@^4.0.0, lodash@~4.17.0, axios@>=1.6.0\n"
@@ -113,7 +124,7 @@ show_version() {
         echo "v$version"
     else
         # Fallback if VERSION file is missing (e.g. during development or if moved)
-        echo "v2.0.4"
+        echo "v2.2.0"
     fi
 }
 
@@ -248,25 +259,6 @@ get_aws_account_info() {
     esac
 }
 
-# Determine compatible runtimes for AWS
-get_compatible_runtimes() {
-    local runtime="$1"
-    local version="2.0.4"
-    
-    case "$runtime" in
-        nodejs)
-            echo "nodejs${version}.x"
-            ;;
-        python)
-            # AWS Lambda uses format like python3.14, not python3.14.x
-            echo "python${version}"
-            ;;
-        *)
-            echo ""
-            ;;
-    esac
-}
-
 # Check dependencies
 check_dependencies() {
     local runtime="$1"
@@ -316,6 +308,7 @@ check_dependencies() {
 # Zip command handler - creates local zip files
 handle_zip() {
     local runtime=""
+    local is_wheel=false
     local packages=""
     
     # Parse runtime flag
@@ -327,6 +320,10 @@ handle_zip() {
         --python|--py|-p)
             runtime="python"
             shift
+            if [[ "${1:-}" == "--wheel" || "${1:-}" == "-w" || "${1:-}" == "--whl" ]]; then
+                 is_wheel=true
+                 shift 
+            fi
             ;;
         --runtime=*)
             runtime="${1#*=}"
@@ -395,7 +392,7 @@ handle_zip() {
     local current_dir=$(pwd)
     cd "$output_dir"
     
-    # Pass arguments to the appropriate script with -i
+    # Pass arguments to the appropriate script
     if [ "$runtime" = "nodejs" ]; then
         if [ ! -f "$NODE_SCRIPT" ]; then
             cd "$current_dir"
@@ -409,23 +406,37 @@ handle_zip() {
         cd "$current_dir"
         exit $exit_code
     elif [ "$runtime" = "python" ]; then
-        if [ ! -f "$PYTHON_SCRIPT" ]; then
+        if [ "$is_wheel" = true ]; then
+             if [ ! -f "$WHEEL_SCRIPT" ]; then
+                cd "$current_dir"
+                printf "${RED}Error: Wheel script not found at $WHEEL_SCRIPT${NC}\n"
+                exit 1
+            fi
+            printf "${BLUE}Creating Lambda layer from Wheel...${NC}\n"
+            bash "$WHEEL_SCRIPT" -w "$packages" "$@"
+            local exit_code=$?
             cd "$current_dir"
-            printf "${RED}Error: Python script not found at $PYTHON_SCRIPT${NC}\n"
-            printf "Please run scripts/install.sh first\n"
-            exit 1
+            exit $exit_code
+        else
+            if [ ! -f "$PYTHON_SCRIPT" ]; then
+                cd "$current_dir"
+                printf "${RED}Error: Python script not found at $PYTHON_SCRIPT${NC}\n"
+                printf "Please run scripts/install.sh first\n"
+                exit 1
+            fi
+            printf "${BLUE}Creating Python Lambda layer (local zip)...${NC}\n"
+            bash "$PYTHON_SCRIPT" -i "$packages" "$@"
+            local exit_code=$?
+            cd "$current_dir"
+            exit $exit_code
         fi
-        printf "${BLUE}Creating Python Lambda layer (local zip)...${NC}\n"
-        bash "$PYTHON_SCRIPT" -i "$packages" "$@"
-        local exit_code=$?
-        cd "$current_dir"
-        exit $exit_code
     fi
 }
 
 # Publish command handler - publishes layer directly to AWS
 handle_publish() {
     local runtime=""
+    local is_wheel=false
     local description=""
     local layer_name=""
     local packages=""
@@ -511,6 +522,11 @@ handle_publish() {
         --python|--py|-p)
             runtime="python"
             shift
+            # Check if the next argument is --wheel
+            if [[ "${1:-}" == "--wheel" || "${1:-}" == "-w" || "${1:-}" == "--whl" ]]; then
+                 is_wheel=true
+                 shift 
+            fi
             ;;
         --runtime=*)
             runtime="${1#*=}"
@@ -543,14 +559,14 @@ handle_publish() {
                 esac
             else
                 printf "${RED}Error: --runtime requires an argument${NC}\n"
-                printf "Example: --runtime=nodejs or --runtime python\n"
+                printf "Example: --runtime=nodejs, --runtime python\n"
                 exit 1
             fi
             ;;
         *)
             printf "${RED}Error: Missing or invalid runtime specification${NC}\n"
-            printf "Use --nodejs, --node, -n for Node.js or --python, --py, -p for Python\n"
-            printf "Or use --runtime=nodejs or --runtime=python\n"
+            printf "Use --nodejs (-n) or --python (-p)\n"
+            printf "Or use --runtime=nodejs, --runtime=python\n"
             exit 1
             ;;
     esac
@@ -560,7 +576,7 @@ handle_publish() {
         packages="$1"
         shift
     else
-        printf "${RED}Error: Missing packages argument${NC}\n"
+        printf "${RED}Error: Missing argument (packages or wheel file)${NC}\n"
         printf "Usage: aws-lambda-layer publish --nodejs <packages> [options]\n"
         printf "Example: aws-lambda-layer publish --nodejs express,axios --description \"My layer\"\n"
         exit 1
@@ -590,7 +606,13 @@ handle_publish() {
     printf "${BLUE}Building Lambda layer in output directory...${NC}\n"
     
     # Build the layer using the appropriate script
-    local build_args=("-i" "$packages")
+    local build_args=()
+    if [ "$is_wheel" = true ]; then
+        build_args+=("-w" "$packages")
+    else
+        build_args+=("-i" "$packages")
+    fi
+    
     if [ -n "$layer_name" ]; then
         build_args+=("--name" "${layer_name}.zip")
     fi
@@ -634,36 +656,75 @@ handle_publish() {
         local compatible_runtimes="nodejs${node_version}.x"
         
     elif [ "$runtime" = "python" ]; then
-        if [ ! -f "$PYTHON_SCRIPT" ]; then
-            cd "$current_dir"
-            printf "${RED}Error: Python script not found${NC}\n"
-            exit 1
-        fi
-        bash "$PYTHON_SCRIPT" "${build_args[@]}" 2>&1 | tee build.log
-        
-        # Check if build script succeeded
-        if [ ${PIPESTATUS[0]} -ne 0 ]; then
-            cd "$current_dir"
-            printf "${RED}Error: Python layer build failed${NC}\n"
-            printf "Check build log: $output_dir/build.log\n"
-            exit 1
-        fi
-        
-        # Extract zip file name from build output (just the filename, not full path)
-        zip_file=$(grep -o "File: .*\.zip" "build.log" | cut -d' ' -f2 | tail -1)
-        if [ -n "$zip_file" ]; then
-            zip_file=$(basename "$zip_file")
+        if [ "$is_wheel" = true ]; then
+            if [ ! -f "$WHEEL_SCRIPT" ]; then
+                cd "$current_dir"
+                printf "${RED}Error: Wheel script not found${NC}\n"
+                exit 1
+            fi
+            bash "$WHEEL_SCRIPT" "${build_args[@]}" 2>&1 | tee build.log
+            
+            if [ ${PIPESTATUS[0]} -ne 0 ]; then
+                cd "$current_dir"
+                printf "${RED}Error: Wheel layer build failed${NC}\n"
+                printf "Check build log: $output_dir/build.log\n"
+                exit 1
+            fi
+            
+            zip_file=$(grep -o "File: .*\.zip" "build.log" | cut -d' ' -f2 | tail -1)
+            if [ -n "$zip_file" ]; then
+                zip_file=$(basename "$zip_file")
+            else
+                zip_file=$(find . -maxdepth 1 -name "*.zip" -type f | head -1 | sed 's|^\./||')
+            fi
+            
+            local python_version=$(grep "Detected Python: " "build.log" | awk -F': ' '{print $2}' | tail -1)
+            if [ -z "$python_version" ]; then python_version="3.12"; fi
+            compatible_runtimes="python${python_version}"
+            
+            local detected_arch=$(grep "Detected Architecture: " "build.log" | awk -F': ' '{print $2}' | tail -1)
+            if [ -n "$detected_arch" ]; then
+                if [ "$detected_arch" = "aarch64" ]; then compatible_architectures="arm64";
+                elif [ "$detected_arch" = "x86_64" ]; then compatible_architectures="x86_64";
+                fi
+            fi
+            
+            if [ -n "${compatible_architectures:-}" ]; then
+                printf "${CYAN}Info: Using detected architecture: $compatible_architectures${NC}\n"
+            fi
         else
-            # Try to find zip file in current directory
-            zip_file=$(find . -maxdepth 1 -name "*.zip" -type f | head -1 | sed 's|^\./||')
-        fi
-        
-        # Extract Python version for compatible runtimes
-        local python_version=$(grep -o "Python: [0-9.]*" "build.log" | cut -d' ' -f2 | tail -1)
-        if [ -z "$python_version" ]; then
-            python_version="3.14"
+            if [ ! -f "$PYTHON_SCRIPT" ]; then
+                cd "$current_dir"
+                printf "${RED}Error: Python script not found${NC}\n"
+                exit 1
+            fi
+            bash "$PYTHON_SCRIPT" "${build_args[@]}" 2>&1 | tee build.log
+            
+            # Check if build script succeeded
+            if [ ${PIPESTATUS[0]} -ne 0 ]; then
+                cd "$current_dir"
+                printf "${RED}Error: Python layer build failed${NC}\n"
+                printf "Check build log: $output_dir/build.log\n"
+                exit 1
+            fi
+            
+            # Extract zip file name from build output (just the filename, not full path)
+            zip_file=$(grep -o "File: .*\.zip" "build.log" | cut -d' ' -f2 | tail -1)
+            if [ -n "$zip_file" ]; then
+                zip_file=$(basename "$zip_file")
+            else
+                # Try to find zip file in current directory
+                zip_file=$(find . -maxdepth 1 -name "*.zip" -type f | head -1 | sed 's|^\./||')
+            fi
+            
+            # Extract Python version for compatible runtimes
+            # Pattern matches "Python version: X.Y" or "Python Version: X.Y"
+            local python_version=$(grep -i "Python.*version: [0-9.]*" "build.log" | awk '{print $NF}' | tail -1)
+            if [ -z "$python_version" ]; then
+                python_version="3.14"
+            fi
+            local compatible_runtimes="python${python_version}"
         fi
-        local compatible_runtimes="python${python_version}"
     fi
     
     # Check if zip file was created
@@ -679,7 +740,11 @@ handle_publish() {
     if [ "$runtime" = "nodejs" ]; then
         packages_info=$(grep -o "Installed packages: .*" "build.log" | cut -d' ' -f3- | tail -1)
     elif [ "$runtime" = "python" ]; then
-        packages_info=$(grep -o "Installed packages: .*" "build.log" | cut -d' ' -f3- | tail -1)
+        if [ "$is_wheel" = true ]; then
+             packages_info=$(basename "$packages")
+        else
+             packages_info=$(grep -o "Installed packages: .*" "build.log" | cut -d' ' -f3- | tail -1)
+        fi
     fi
     
     # Determine layer name - use just the first package name if not specified
@@ -692,7 +757,11 @@ handle_publish() {
             layer_name=$(echo "$first_package" | sed 's/@[0-9^~<>=].*$//' | sed 's/^@//' | tr '/' '-')
         else
             # For Python: remove ==version, >=version, etc.
-            layer_name=$(echo "$first_package" | sed 's/[=<>~!].*$//')
+            if [ "$is_wheel" = true ]; then
+                 layer_name=$(basename "$first_package" | cut -d'-' -f1)
+            else
+                 layer_name=$(echo "$first_package" | sed 's/[=<>~!].*$//')
+            fi
         fi
     fi
     
@@ -748,16 +817,32 @@ handle_publish() {
     printf "  --layer-name \"$layer_name\"\n"
     printf "  --description \"$final_description\"\n"
     printf "  --zip-file \"fileb://$(convert_path "$current_dir/$output_dir/$zip_file")\"\n"
-    printf "  --compatible-runtimes \"$compatible_runtimes\"\n\n"
+    printf "  --compatible-runtimes \"$compatible_runtimes\"\n"
+    if [ -n "${compatible_architectures:-}" ]; then
+        printf "  --compatible-architectures \"$compatible_architectures\"\n"
+    fi
+    printf "\n"
     
+    # Build AWS CLI command array
+    local publish_cmd=(aws)
+    if [ ${#publish_aws_opts[@]} -gt 0 ]; then
+        publish_cmd+=("${publish_aws_opts[@]}")
+    fi
+    publish_cmd+=(lambda publish-layer-version)
+    publish_cmd+=(--layer-name "$layer_name")
+    publish_cmd+=(--description "$final_description")
+    publish_cmd+=(--zip-file "fileb://$(convert_path "$current_dir/$output_dir/$zip_file")")
+    publish_cmd+=(--compatible-runtimes "$compatible_runtimes")
+    
+    if [ -n "${compatible_architectures:-}" ]; then
+        publish_cmd+=(--compatible-architectures "$compatible_architectures")
+    fi
+    
+    publish_cmd+=(--query '[LayerVersionArn, Version, Description]')
+    publish_cmd+=(--output table)
+
     # Run AWS CLI command and capture output and exit code
-    aws ${publish_aws_opts[@]+"${publish_aws_opts[@]}"} lambda publish-layer-version \
-        --layer-name "$layer_name" \
-        --description "$final_description" \
-        --zip-file "fileb://$(convert_path "$current_dir/$output_dir/$zip_file")" \
-        --compatible-runtimes "$compatible_runtimes" \
-        --query '[LayerVersionArn, Version, Description]' \
-        --output table 2>&1 | tee publish.log
+    "${publish_cmd[@]}" 2>&1 | tee publish.log
     
     local aws_exit_code=${PIPESTATUS[0]}
     

package/scripts/build_pypi.sh

@@ -25,6 +25,7 @@ cp "$BASE_DIR/VERSION.txt" "$BUILD_DIR/"
 cp "$BASE_DIR/scripts/aws-lambda-layer-cli" "$ASSETS_DIR/"
 cp "$BASE_DIR/scripts/create_nodejs_layer.sh" "$ASSETS_DIR/"
 cp "$BASE_DIR/scripts/create_python_layer.sh" "$ASSETS_DIR/"
+cp "$BASE_DIR/scripts/create_wheel_layer.sh" "$ASSETS_DIR/"
 cp "$BASE_DIR/scripts/uninstall.sh" "$ASSETS_DIR/"
 
 # Copy completion files
@@ -40,6 +41,6 @@ cd "$BASE_DIR"
 python3 -m build
 
 echo "Cleaning up temporary package files..."
-# rm -rf "$BUILD_DIR" "$BASE_DIR/aws_lambda_layer_cli.egg-info" "$BASE_DIR/build"
+rm -rf "$BUILD_DIR" "$BASE_DIR/aws_lambda_layer_cli.egg-info" "$BASE_DIR/build"
 
 echo "Build complete! Artifacts are in dist/"

package/scripts/create_python_layer.sh

@@ -1,10 +1,10 @@
 #!/bin/bash
 
-# Python Lambda Layer Creator with UV and version specification
+# Python Lambda Layer Creator with version specification
 # Usage:
 #   ./create_python_layer.sh -i numpy==1.26.0,pandas==2.1.3
 #   ./create_python_layer.sh -i numpy==1.26.0,pandas,boto3==1.34.0 -n my-layer.zip
-#   ./create_python_layer.sh --packages=requests==2.31.0,boto3 --no-uv
+#   ./create_python_layer.sh --packages=requests==2.31.0,boto3
 
 set -e  # Exit on error
 set -u  # Treat unset variables as errors
@@ -19,8 +19,11 @@ LAYER_NAME=""
 PYTHON_VERSION="3.14"  # Default to Python 3.14
 PYTHON_VERSION_SPECIFIED=false
 VENV_DIR="python"
-USE_UV=true
 ORIGINAL_DIR=$(pwd)
+PLATFORM=""  # Optional platform targeting
+IMPLEMENTATION="cp"
+ABI=""
+ARCHITECTURE="x86_64"  # Default architecture
 
 # Colors for output
 RED='\033[0;31m'
@@ -137,24 +140,33 @@ while [[ $# -gt 0 ]]; do
             validate_python_version "$PYTHON_VERSION"
             shift
             ;;
-        --no-uv)
-            USE_UV=false
+        -a|--architecture)
+            if [[ -n "${2:-}" && "${2:-}" != -* ]]; then
+                ARCHITECTURE="$2"
+                shift 2
+            else
+                printf "${RED}Error: $1 requires an argument${NC}\n"
+                printf "Example: $1 arm64\n"
+                exit 1
+            fi
+            ;;
+        --architecture=*)
+            ARCHITECTURE="${1#*=}"
             shift
             ;;
         -h|--help)
             cat << 'EOF'
-Python Lambda Layer Creator with UV
+Python Lambda Layer Creator
 
 Usage:
   ./create_python_layer.sh -i numpy==1.26.0,pandas==2.1.3
   ./create_python_layer.sh --packages=numpy==1.26.0,pandas,boto3==1.34.0 -n my-layer.zip
-  ./create_python_layer.sh -i flask==3.0.0 --no-uv
 
 Options:
   -i, --packages        Comma-separated list of Python packages (with optional versions)
   -n, --name            Name of the output zip file
   --python-version      Python version (default: 3.14)
-  --no-uv               Use pip/venv instead of uv
+  -a, --architecture    Target architecture (x86_64 or arm64, default: x86_64)
   -h, --help            Show this help message
 
 Version Specification:
@@ -167,9 +179,14 @@ Version Specification:
     Django!=3.2.0               # Version exclusion
 
 Examples:
+  # Basic usage
   ./create_python_layer.sh -i numpy==1.26.0
-  ./create_python_layer.sh -i requests==2.31.0,boto3==1.34.0 --python-version=3.14
-  ./create_python_layer.sh --packages=pandas==2.1.3,scikit-learn==1.3.0 --no-uv -n ml-layer.zip
+
+  # With platform targeting for Amazon Linux 2023
+  ./create_python_layer.sh -i requests==2.31.0,boto3==1.34.0 --python-version=3.13 --platform=manylinux_2_28_x86_64
+
+  # With platform targeting for ARM64
+  ./create_python_layer.sh --packages=pandas==2.1.3,scikit-learn==1.3.0 --platform=manylinux_2_28_aarch64 -n ml-layer.zip
 EOF
             exit 0
             ;;
@@ -189,14 +206,6 @@ if [ -z "$PACKAGES" ]; then
     exit 1
 fi
 
-# Check if uv is available safely
-if [ "$USE_UV" = true ]; then
-    if ! command -v uv >/dev/null 2>&1; then
-        printf "${YELLOW}Warning: uv not found, falling back to pip/venv${NC}\n"
-        USE_UV=false
-    fi
-fi
-
 # Check dependencies
 if ! command -v zip &> /dev/null; then
     printf "${RED}Error: 'zip' command is not installed${NC}\n"
@@ -236,12 +245,29 @@ if [ "$PACKAGES" != "$SANITIZED_PACKAGES" ]; then
     PACKAGES="$SANITIZED_PACKAGES"
 fi
 
+# Normalize Architecture
+AWS_ARCH="$ARCHITECTURE"
+if [ "$ARCHITECTURE" = "arm64" ]; then
+    ARCHITECTURE="aarch64"
+    AWS_ARCH="arm64"
+elif [ "$ARCHITECTURE" = "amd64" ]; then
+    ARCHITECTURE="x86_64"
+    AWS_ARCH="x86_64"
+elif [ "$ARCHITECTURE" = "x86_64" ]; then
+    AWS_ARCH="x86_64"
+elif [ "$ARCHITECTURE" = "aarch64" ]; then
+    AWS_ARCH="arm64"
+fi
+
 printf "${BLUE}=========================================${NC}\n"
 printf "${GREEN}Python Lambda Layer Creator${NC}\n"
 printf "${BLUE}=========================================${NC}\n"
 printf "Packages: $PACKAGES\n"
 printf "Python version: $PYTHON_VERSION\n"
-printf "Using UV: $USE_UV\n"
+printf "Target Architecture: $AWS_ARCH\n"
+if [ -n "$PLATFORM" ]; then
+    printf "Platform: $PLATFORM\n"
+fi
 if [ -n "$LAYER_NAME" ]; then
     printf "Output name: $LAYER_NAME\n"
 fi
@@ -277,20 +303,12 @@ if ! command -v "$TARGET_PYTHON" >/dev/null 2>&1; then
     fi
 fi
 
-if [ "$USE_UV" = true ]; then
-    printf "  Using UV to create venv...\n"
-    if ! uv venv --python "$TARGET_PYTHON" "$VENV_DIR"; then
-         printf "${RED}Error: Failed to create venv with uv${NC}\n"
-         exit 1
-    fi
+printf "  Using venv module...\n"
+if command -v "$TARGET_PYTHON" >/dev/null 2>&1; then
+    "$TARGET_PYTHON" -m venv "$VENV_DIR"
 else
-    printf "  Using venv module...\n"
-    if command -v "$TARGET_PYTHON" >/dev/null 2>&1; then
-        "$TARGET_PYTHON" -m venv "$VENV_DIR"
-    else
-        printf "${RED}Error: $TARGET_PYTHON not found${NC}\n"
-        exit 1
-    fi
+    printf "${RED}Error: $TARGET_PYTHON not found${NC}\n"
+    exit 1
 fi
 
 # Activate virtual environment
@@ -307,16 +325,64 @@ set -u
 
 # Step 3: Install packages with versions
 printf "[3/7] Installing packages...\n"
-if [ "$USE_UV" = true ]; then
-    printf "  Installing with UV...\n"
-    # Convert to array for safe expansion
-    IFS=',' read -ra PKG_ARRAY <<< "$PACKAGES"
-    uv pip install "${PKG_ARRAY[@]}"
+
+# Auto-detect platform if not specified
+if [ -z "$PLATFORM" ]; then
+    # Calculate major/minor version
+    # PYTHON_VERSION is like 3.14 or 3.14.2
+    PY_VER_MAJOR=$(echo "$PYTHON_VERSION" | cut -d. -f1)
+    PY_VER_MINOR=$(echo "$PYTHON_VERSION" | cut -d. -f2)
+    
+    # Platform selection based on AWS Lambda Runtime
+    if [ "$PY_VER_MAJOR" -eq 3 ] && [ "$PY_VER_MINOR" -ge 12 ]; then
+        # Python 3.12+ runs on Amazon Linux 2023 (GLIBC 2.34)
+        # We use manylinux_2_28 (GLIBC 2.28) which is well-supported
+        PLATFORM_PREFIX="manylinux_2_28"
+        printf "  Targeting Amazon Linux 2023 (Python $PYTHON_VERSION)\n"
+    else
+        # Python 3.11- runs on Amazon Linux 2 (GLIBC 2.26)
+        # We use manylinux2014 (GLIBC 2.17) for max compatibility
+        PLATFORM_PREFIX="manylinux2014"
+        printf "  Targeting Amazon Linux 2 (Python $PYTHON_VERSION)\n"
+    fi
+    
+    PLATFORM="${PLATFORM_PREFIX}_${ARCHITECTURE}"
+    printf "Auto-detected platform: $PLATFORM (Python $PYTHON_VERSION, Arch $ARCHITECTURE)\n"
+fi
+
+# Prepare platform-specific options
+INSTALL_OPTS=()
+if [ -n "$PLATFORM" ]; then
+    # Calculate ABI tag based on Python version (e.g., 3.12 -> cp312)
+    # We use cut instead of potentially fragile regex
+    PY_MAJOR=$(echo "$PYTHON_VERSION" | cut -d. -f1)
+    PY_MINOR=$(echo "$PYTHON_VERSION" | cut -d. -f2)
+    ABI="cp${PY_MAJOR}${PY_MINOR}"
+    
+    INSTALL_OPTS+=("--platform" "$PLATFORM")
+    INSTALL_OPTS+=("--implementation" "$IMPLEMENTATION")
+    INSTALL_OPTS+=("--python-version" "$PYTHON_VERSION")
+    INSTALL_OPTS+=("--abi" "$ABI")
+    INSTALL_OPTS+=("--only-binary=:all:")
+    printf "  Using platform-specific installation: $PLATFORM\n"
+    printf "  ABI tag: $ABI\n"
+fi
+
+printf "  Installing with pip...\n"
+# Convert to array for safe expansion
+IFS=',' read -ra PKG_ARRAY <<< "$PACKAGES"
+if [ ${#INSTALL_OPTS[@]} -gt 0 ]; then
+    # When using platform specific options, we must specify --target
+    # We use the site-packages directory of the current venv
+    SITE_PACKAGES=$(python -c "import site; print(site.getsitepackages()[0])")
+    printf "  Targeting site-packages: $SITE_PACKAGES\n"
+    CMD=(pip install "${PKG_ARRAY[@]}" "${INSTALL_OPTS[@]}" --target "$SITE_PACKAGES")
+    echo "  Running: ${CMD[*]}"
+    "${CMD[@]}"
 else
-    printf "  Installing with pip...\n"
-    # Convert to array for safe expansion
-    IFS=',' read -ra PKG_ARRAY <<< "$PACKAGES"
-    pip install "${PKG_ARRAY[@]}"
+    CMD=(pip install "${PKG_ARRAY[@]}")
+    echo "  Running: ${CMD[*]}"
+    "${CMD[@]}"
 fi
 
 # Count packages from command argument
@@ -333,11 +399,7 @@ if [ -z "$LAYER_NAME" ]; then
         printf "  Single package: $PKG_NAME\n"
         
         # Extract version from installed package
-        if [ "$USE_UV" = true ]; then
-            PKG_INFO=$(uv pip show "$PKG_NAME" 2>/dev/null || true)
-        else
-            PKG_INFO=$(pip show "$PKG_NAME" 2>/dev/null || true)
-        fi
+        PKG_INFO=$(pip show "$PKG_NAME" 2>/dev/null || true)
         
         if [ -n "$PKG_INFO" ]; then
             # Use safer extraction methods
@@ -400,11 +462,7 @@ fi
 
 # Step 5: Show installed packages
 printf "[5/7] Listing installed packages...\n"
-if [ "$USE_UV" = true ]; then
-    uv pip list --format freeze
-else
-    pip list --format freeze
-fi
+pip list --format freeze
 
 # Deactivate virtual environment
 set +u
@@ -433,7 +491,7 @@ printf "${GREEN}✅ SUCCESS: Python Lambda Layer Created${NC}\n"
 printf "${BLUE}=========================================${NC}\n"
 printf "📁 File: $ORIGINAL_DIR/$LAYER_NAME\n"
 printf "🐍 Python Version: $PYTHON_VERSION\n"
-printf "⚡ Tool: $(if [ "$USE_UV" = true ]; then echo "UV"; else echo "pip/venv"; fi)\n"
+printf "⚡ Tool: pip/venv\n"
 printf "📦 Size: $(du -h "$ORIGINAL_DIR/$LAYER_NAME" | cut -f1)\n"
 printf "📊 Package Count: $PACKAGE_COUNT\n"
 
@@ -446,11 +504,7 @@ for pkg_full in "${PKG_ARRAY[@]}"; do
     pkg_name=$(extract_package_name "$pkg_full")
     
     # Get installed version from pip show or metadata
-    if [ "$USE_UV" = true ]; then
-        installed_ver=$(find . -type f -name "METADATA" -path "*/${pkg_name}-*.dist-info/METADATA" -exec grep -h "^Version:" {} \; | head -1 | cut -d' ' -f2)
-    else
-        installed_ver=$(find . -type f -name "METADATA" -path "*/${pkg_name}-*.dist-info/METADATA" -exec grep -h "^Version:" {} \; | head -1 | cut -d' ' -f2)
-    fi
+    installed_ver=$(find . -type f -name "METADATA" -path "*/${pkg_name}-*.dist-info/METADATA" -exec grep -h "^Version:" {} \; | head -1 | cut -d' ' -f2)
     
     if [ -n "$installed_ver" ]; then
         if [ -n "$INSTALLED_PKGS" ]; then

package/scripts/create_wheel_layer.sh

@@ -0,0 +1,458 @@
+#!/bin/bash
+
+# Python Lambda Layer Creator from Wheel
+# Usage:
+#   ./create_wheel_layer.sh -w mypackage.whl
+#   ./create_wheel_layer.sh -w mypackage.whl -i "pandas,boto3" -n my-layer.zip
+
+set -e
+set -u
+
+# Default values
+WHEEL_FILE=""
+PACKAGES=""
+LAYER_NAME=""
+# We now track user provided values separate from defaults
+USER_PYTHON_VERSION=""
+USER_ARCHITECTURE=""
+USER_PLATFORM=""
+
+DEFAULT_PYTHON_VERSION="3.12"
+DEFAULT_ARCHITECTURE="x86_64"
+
+PYTHON_VERSION="$DEFAULT_PYTHON_VERSION"
+ARCHITECTURE="$DEFAULT_ARCHITECTURE"
+PLATFORM=""
+IMPLEMENTATION="cp"
+ABI=""  # Will be calculated
+
+# Colors
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+NC='\033[0m'
+
+# Parse arguments
+while [[ $# -gt 0 ]]; do
+    case "$1" in
+        -w|--wheel)
+            if [[ -n "${2:-}" && "${2:-}" != -* ]]; then
+                WHEEL_FILE="$2"
+                shift 2
+            else
+                printf "${RED}Error: $1 requires an argument${NC}\n"
+                exit 1
+            fi
+            ;;
+        --wheel=*)
+            WHEEL_FILE="${1#*=}"
+            shift
+            ;;
+        -i|--packages)
+            if [[ -n "${2:-}" && "${2:-}" != -* ]]; then
+                PACKAGES="$2"
+                shift 2
+            else
+                printf "${RED}Error: $1 requires an argument${NC}\n"
+                exit 1
+            fi
+            ;;
+        --packages=*)
+            PACKAGES="${1#*=}"
+            shift
+            ;;
+        -n|--name)
+            if [[ -n "${2:-}" && "${2:-}" != -* ]]; then
+                LAYER_NAME="$2"
+                shift 2
+            else
+                printf "${RED}Error: $1 requires an argument${NC}\n"
+                exit 1
+            fi
+            ;;
+        --name=*)
+            LAYER_NAME="${1#*=}"
+            shift
+            ;;
+        --python-version)
+            if [[ -n "${2:-}" && "${2:-}" != -* ]]; then
+                USER_PYTHON_VERSION="$2"
+                PYTHON_VERSION="$2"
+                shift 2
+            else
+                printf "${RED}Error: $1 requires an argument${NC}\n"
+                exit 1
+            fi
+            ;;
+        --python-version=*)
+            USER_PYTHON_VERSION="${1#*=}"
+            PYTHON_VERSION="${1#*=}"
+            shift
+            ;;
+        --architecture|-a)
+            if [[ -n "${2:-}" && "${2:-}" != -* ]]; then
+                USER_ARCHITECTURE="$2"
+                ARCHITECTURE="$2"
+                shift 2
+            else
+                printf "${RED}Error: $1 requires an argument${NC}\n"
+                exit 1
+            fi
+            ;;
+        --architecture=*)
+            USER_ARCHITECTURE="${1#*=}"
+            ARCHITECTURE="${1#*=}"
+            shift
+            ;;
+        -h|--help)
+            cat << 'EOF'
+Usage: ./create_wheel_layer.sh -w <wheel_file> [-i <packages>] [-n <zip_name>]
+
+Options:
+  -w, --wheel          Path to .whl file
+  -i, --packages       Additional packages (comma or space separated)
+  -n, --name           Output zip filename
+  --python-version     Target Python version (default: 3.12)
+  -a, --architecture   Target architecture (x86_64, arm64)
+
+Supported Architectures:
+  x86_64 (amd64)       # Standard Intel/AMD 64-bit
+  arm64 (aarch64)      # AWS Graviton (ARM 64-bit)
+
+Examples:
+  # Build for Amazon Linux 2 (Python 3.12, x86_64)
+  ./create_wheel_layer.sh -w mypackage.whl --python-version=3.12
+
+  # Build for ARM64
+  ./create_wheel_layer.sh -w mypackage.whl -a arm64
+EOF
+            exit 0
+            ;;
+        *)
+            printf "${RED}Unknown option: $1${NC}\n"
+            exit 1
+            ;;
+    esac
+done
+
+# Validation
+if [ -z "$WHEEL_FILE" ]; then
+    printf "${RED}Error: Wheel file is required (-w)${NC}\n"
+    exit 1
+fi
+# Detect pip
+PIP_EXE=""
+if command -v pip &> /dev/null; then
+    PIP_EXE="pip"
+elif command -v pip3 &> /dev/null; then
+    PIP_EXE="pip3"
+else
+    printf "${RED}Error: pip or pip3 not found. Please install Python and pip.${NC}\n"
+    exit 1
+fi
+if [ ! -f "$WHEEL_FILE" ]; then
+    printf "${RED}Error: File $WHEEL_FILE not found${NC}\n"
+    exit 1
+fi
+
+# ------------------------------------------------------------------
+# WHEEL METADATA AUTO-DETECTION
+# ------------------------------------------------------------------
+# Extract metadata directly from filename/wheel to enforce strictness
+# Format: Name-Ver-PyTag-AbiTag-PlatTag.whl
+
+DETECTED_PY="any"
+DETECTED_ABI="none"
+DETECTED_PLAT="any"
+DETECTED_ARCH="any"
+
+# Helper python script to parse filename strictly
+META_OUT=$(python3 -c "
+import sys
+import os
+
+filename = os.path.basename(sys.argv[1])
+if filename.endswith('.whl'):
+    filename = filename[:-4]
+    
+parts = filename.split('-')
+# Minimal check: Name-Ver-Py-Abi-Plat
+if len(parts) >= 5:
+    plat = parts[-1]
+    abi = parts[-2]
+    py = parts[-3]
+    
+    # Arch mapping
+    arch = 'any'
+    if 'x86_64' in plat or 'amd64' in plat:
+        arch = 'x86_64'
+    elif 'aarch64' in plat or 'arm64' in plat:
+        arch = 'aarch64'
+        
+    # Py Ver extraction (cp312->3.12)
+    py_ver = 'any'
+    if py.startswith('cp') and len(py) > 2 and py[2:].isdigit():
+        pv_raw = py[2:]
+        if len(pv_raw) == 2: # 39
+             py_ver = f'{pv_raw[0]}.{pv_raw[1]}'
+        elif len(pv_raw) >= 3: # 312
+             major = pv_raw[0]
+             minor = pv_raw[1:]
+             py_ver = f'{major}.{minor}'
+    
+    print(f'{py_ver}|{arch}|{plat}|{abi}')
+else:
+    print('any|any|any|none')
+" "$WHEEL_FILE")
+
+IFS='|' read -r DET_PY DET_ARCH DET_PLAT DET_ABI <<< "$META_OUT"
+
+# STRICT MODE ENFORCEMENT
+# If the wheel is binary (specific architecture or python), we ENFORCE it.
+# If the wheel is 'any', we allow defaults or user args.
+
+if [ "$DET_PY" != "any" ]; then
+    if [ -n "$USER_PYTHON_VERSION" ] && [ "$USER_PYTHON_VERSION" != "$DET_PY" ]; then
+        printf "${RED}Error: Wheel is for Python $DET_PY, but you requested $USER_PYTHON_VERSION.${NC}\n"
+        printf "Please remove the argument or use matching version.\n"
+        exit 1
+    fi
+    # Auto-set
+    PYTHON_VERSION="$DET_PY"
+    printf "Detected Python: $PYTHON_VERSION\n"
+fi
+
+if [ "$DET_ARCH" != "any" ]; then
+    if [ -n "$USER_ARCHITECTURE" ]; then
+        # Normalize user input for comparison
+        NORM_USER_ARCH="$USER_ARCHITECTURE"
+        if [ "$USER_ARCHITECTURE" == "arm64" ]; then NORM_USER_ARCH="aarch64"; fi
+        if [ "$USER_ARCHITECTURE" == "amd64" ]; then NORM_USER_ARCH="x86_64"; fi
+        
+        if [ "$NORM_USER_ARCH" != "$DET_ARCH" ]; then
+             printf "${RED}Error: Wheel is for $DET_ARCH, but you requested $USER_ARCHITECTURE.${NC}\n"
+             exit 1
+        fi
+    fi
+    # Auto-set
+    ARCHITECTURE="$DET_ARCH" 
+    printf "Detected Architecture: $ARCHITECTURE\n"
+fi
+
+if [ "$DET_PLAT" != "any" ] && [ -z "$USER_PLATFORM" ]; then
+    # Only override platform if user didn't specify one (pip might need specific one)
+    # But usually filename platform is correct for install
+    PLATFORM="$DET_PLAT"
+fi
+
+if [ "$DET_ABI" != "none" ]; then
+    ABI="$DET_ABI"
+fi
+
+# Normalize Architecture
+AWS_ARCH="$ARCHITECTURE"
+if [ "$ARCHITECTURE" = "arm64" ] || [ "$ARCHITECTURE" = "aarch64" ]; then
+    ARCHITECTURE="aarch64"
+    AWS_ARCH="arm64"
+elif [ "$ARCHITECTURE" = "amd64" ] || [ "$ARCHITECTURE" = "x86_64" ]; then
+    ARCHITECTURE="x86_64"
+    AWS_ARCH="x86_64"
+fi
+
+# Determine Platform if still empty
+if [ -z "$PLATFORM" ]; then
+    # Default to manylinux2014 as it is safe for both AL2 and AL2023
+    PLATFORM="manylinux2014_${ARCHITECTURE}"
+fi
+
+
+# Validate Wheel Suitability for Lambda (Linux) using metadata
+printf "Validating wheel compatibility...\n"
+
+# Only run python validation if python is available (it should be, given pip is used)
+PYTHON_EXE=""
+if command -v python3 &> /dev/null; then
+    PYTHON_EXE="python3"
+elif command -v python &> /dev/null; then
+    PYTHON_EXE="python"
+fi
+
+if [ -n "$PYTHON_EXE" ]; then
+    # Use Python to inspect the WHEEL metadata for accurate tags
+    $PYTHON_EXE -c "
+import sys, zipfile, os
+
+try:
+    wheel_path = sys.argv[1]
+    target_arch = sys.argv[2]
+    
+    # Define compatibility
+    compatible_os = ['manylinux', 'linux', 'any']
+    
+    arch_map = {
+        'x86_64': ['x86_64', 'amd64', 'any'],
+        'arm64': ['aarch64', 'arm64', 'any'],
+        'aarch64': ['aarch64', 'arm64', 'any']
+    }
+    
+    with zipfile.ZipFile(wheel_path, 'r') as z:
+        # Find .dist-info/WHEEL
+        wheel_files = [f for f in z.namelist() if f.endswith('.dist-info/WHEEL')]
+        if not wheel_files:
+            # Fallback for old wheels without WHEEL metadata (rare)
+            print('Warning: No .dist-info/WHEEL found, skipping strict validation.')
+            sys.exit(0)
+            
+        content = z.read(wheel_files[0]).decode('utf-8')
+        tags = []
+        for line in content.splitlines():
+            if line.startswith('Tag:'):
+                tags.append(line.split(':', 1)[1].strip())
+        
+        has_linux = False
+        has_arch = False
+        detected_plats = set()
+        
+        for tag in tags:
+            parts = tag.split('-')
+            if len(parts) >= 3:
+                plat = parts[2]
+                detected_plats.add(plat)
+                
+                # Check OS
+                if any(x in plat for x in compatible_os):
+                    has_linux = True
+                
+                # Check Arch
+                target_valid_archs = arch_map.get(target_arch, [])
+                
+                # Special handling for 'any' to avoid matching 'manylinux'
+                if plat == 'any' and 'any' in target_valid_archs:
+                    has_arch = True
+                else:
+                    # Filter out 'any' from search strings for substring check
+                    search_archs = [x for x in target_valid_archs if x != 'any']
+                    if any(x in plat for x in search_archs):
+                        has_arch = True
+
+        if not has_linux:
+            print(f'Error: Wheel is not compatible with Linux.\nDetected platforms: {', '.join(sorted(detected_plats))}')
+            sys.exit(1)
+            
+        if not has_arch:
+            print(f'Error: Wheel architecture mismatch.\nTarget: {target_arch}\nDetected platforms: {', '.join(sorted(detected_plats))}')
+            sys.exit(1)
+            
+except Exception as e:
+    print(f'Warning: Could not validate wheel metadata: {e}')
+    sys.exit(0) # Don't block build if validation script itself crashes
+" "$WHEEL_FILE" "$ARCHITECTURE"
+
+    # Check exit code of python script
+    if [ $? -ne 0 ]; then
+        exit 1
+    fi
+else
+    # Fallback to simple filename check if python not found (unlikely)
+    WHEEL_BASENAME=$(basename "$WHEEL_FILE")
+    if [[ "$WHEEL_BASENAME" == *"macosx"* ]] || [[ "$WHEEL_BASENAME" == *"win32"* ]]; then
+         printf "${YELLOW}Warning: Filename suggests non-Linux wheel ($WHEEL_BASENAME)${NC}\n"
+    fi
+fi
+
+# Determine ABI tag (If not auto-detected)
+# e.g., 3.12 -> cp312, 3.10 -> cp310
+if [ -z "$ABI" ] || [ "$ABI" == "none" ]; then
+    PY_MAJOR=$(echo "$PYTHON_VERSION" | cut -d. -f1)
+    PY_MINOR=$(echo "$PYTHON_VERSION" | cut -d. -f2)
+    ABI="cp${PY_MAJOR}${PY_MINOR}"
+fi
+
+if [ -z "$LAYER_NAME" ]; then
+    BASENAME=$(basename "$WHEEL_FILE" .whl)
+    LAYER_NAME="${BASENAME}_layer.zip"
+fi
+
+# Setup workspace
+LAYER_DIR="layer_build_$(date +%s)"
+ORIGINAL_DIR=$(pwd)
+
+# Convert relative paths to absolute
+if [[ "$WHEEL_FILE" != /* ]]; then
+    WHEEL_FILE="$ORIGINAL_DIR/$WHEEL_FILE"
+fi
+
+printf "${GREEN}Creating Lambda layer from wheel...${NC}\n"
+printf "Wheel: $WHEEL_FILE\n"
+if [ -n "$PACKAGES" ]; then
+    printf "Extra Packages: $PACKAGES\n"
+fi
+printf "Target Architecture: $AWS_ARCH\n"
+printf "Platform Tag: $PLATFORM\n"
+printf "Python: $PYTHON_VERSION (ABI: $ABI)\n"
+
+mkdir -p "$LAYER_DIR/python"
+
+# Install
+printf "${GREEN}Installing packages...${NC}\n"
+CMD=("$PIP_EXE" "install" "$WHEEL_FILE")
+
+if [ -n "$PACKAGES" ]; then
+    # Replace commas with spaces
+    PKG_SPACE=$(echo "$PACKAGES" | tr ',' ' ')
+    # Split into array
+    read -ra PKG_ARRAY <<< "$PKG_SPACE"
+    CMD+=("${PKG_ARRAY[@]}")
+fi
+
+CMD+=("--target" "$LAYER_DIR/python")
+
+# Handle multiple platform tags (e.g. manylinux1_x86_64.linux_x86_64)
+# Split by dot and add each as separate --platform argument
+IFS='.' read -ra PLAT_TAGS <<< "$PLATFORM"
+for tag in "${PLAT_TAGS[@]}"; do
+    CMD+=("--platform" "$tag")
+done
+
+CMD+=("--implementation" "$IMPLEMENTATION")
+CMD+=("--python-version" "$PYTHON_VERSION")
+CMD+=("--abi" "$ABI")
+CMD+=("--only-binary=:all:")
+CMD+=("--upgrade")
+
+echo "Running: ${CMD[*]}"
+if ! "${CMD[@]}"; then
+    printf "${RED}Installation failed${NC}\n"
+    rm -rf "$LAYER_DIR"
+    exit 1
+fi
+
+# Cleanup
+printf "${GREEN}Removing cache and metadata...${NC}\n"
+find "$LAYER_DIR" -type d -name "__pycache__" -exec rm -rf {} +
+# Removing dist-info might break some packages (entry points, metadata), but user requested space saving
+# Making it optional or just following user's script. Following user script:
+find "$LAYER_DIR" -type d -name "*.dist-info" -exec rm -rf {} +
+
+# Zip
+printf "${GREEN}Zipping to $LAYER_NAME...${NC}\n"
+cd "$LAYER_DIR"
+
+# Handle absolute vs relative path for LAYER_NAME
+ZIP_DEST="$LAYER_NAME"
+if [[ "$LAYER_NAME" != /* ]]; then
+    ZIP_DEST="$ORIGINAL_DIR/$LAYER_NAME"
+fi
+
+if zip -r "$ZIP_DEST" python > /dev/null; then
+    printf "${GREEN}✅ Done! Created $LAYER_NAME${NC}\n"
+    printf "File: $(basename "$LAYER_NAME")\n"
+else
+    printf "${RED}Error creating zip file at $ZIP_DEST${NC}\n"
+    cd "$ORIGINAL_DIR"
+    rm -rf "$LAYER_DIR"
+    exit 1
+fi
+
+cd "$ORIGINAL_DIR"
+rm -rf "$LAYER_DIR"

package/scripts/install.ps1

@@ -44,7 +44,7 @@ if ([string]::IsNullOrEmpty($InstallDir)) {
 # Configuration
 $RepoUrl = "https://github.com/yukcw/aws-lambda-layer-cli"
 $ToolName = "aws-lambda-layer-cli"
-$Version = "2.0.4" # Fallback version
+$Version = "2.2.0" # Fallback version
 
 # Colors for output
 $Green = "Green"