aws-lambda-layer-cli 2.1.3 → 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 (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,12 +46,12 @@ 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`) |
-| `--platform` | Target platform tag (Python only, e.g. `manylinux_2_28_aarch64`) |
 | `--node-version` | Node.js version (default: 24) |
 | `--python-version` | Python version (default: 3.14) |
 | `-v, --version` | Show version |
@@ -72,9 +72,23 @@ aws-lambda-layer-cli publish --nodejs lodash --profile prod --region us-east-1 -
 # 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 with explicit platform tag (e.g. Amazon Linux 2023 / manylinux_2_28)
-aws-lambda-layer-cli publish --python requests --name web-layer --platform manylinux_2_28_x86_64
+# 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.1.3",
+  "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.1.3"
+    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,8 +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}--architecture, -a${NC}      Target architecture (x86_64, arm64)\n"
-    printf "  ${YELLOW}--platform${NC}              Target platform tag (Python only)\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"
@@ -114,7 +124,7 @@ show_version() {
         echo "v$version"
     else
         # Fallback if VERSION file is missing (e.g. during development or if moved)
-        echo "v2.1.3"
+        echo "v2.2.0"
     fi
 }
 
@@ -249,25 +259,6 @@ get_aws_account_info() {
     esac
 }
 
-# Determine compatible runtimes for AWS
-get_compatible_runtimes() {
-    local runtime="$1"
-    local version="2.1.3"
-    
-    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"
@@ -317,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
@@ -328,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#*=}"
@@ -396,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"
@@ -410,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=""
@@ -512,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#*=}"
@@ -544,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
@@ -561,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
@@ -591,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
@@ -635,37 +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
-        # 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"
+            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
@@ -681,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
@@ -694,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
     
@@ -750,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
@@ -140,20 +140,6 @@ while [[ $# -gt 0 ]]; do
             validate_python_version "$PYTHON_VERSION"
             shift
             ;;
-        --platform)
-            if [[ -n "${2:-}" && "${2:-}" != -* ]]; then
-                PLATFORM="$2"
-                shift 2
-            else
-                printf "${RED}Error: $1 requires an argument${NC}\n"
-                printf "Example: $1 manylinux_2_28_x86_64\n"
-                exit 1
-            fi
-            ;;
-        --platform=*)
-            PLATFORM="${1#*=}"
-            shift
-            ;;
         -a|--architecture)
             if [[ -n "${2:-}" && "${2:-}" != -* ]]; then
                 ARCHITECTURE="$2"
@@ -180,18 +166,9 @@ 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)
-  --platform            Target platform tag (optional, overrides architecture)
   -a, --architecture    Target architecture (x86_64 or arm64, default: x86_64)
   -h, --help            Show this help message
 
-Supported Platforms (optional):
-  manylinux2014_x86_64    # Amazon Linux 2, RHEL 7+ (older)
-  manylinux2014_aarch64   # ARM64 architecture
-  manylinux_2_28_x86_64   # Amazon Linux 2023, RHEL 8+ (newer)
-  manylinux_2_28_aarch64  # ARM64 with newer glibc
-  linux_x86_64            # Generic Linux
-  linux_aarch64           # Generic ARM64 Linux
-
 Version Specification:
   Package versions can be specified using standard Python version specifiers:
     numpy==1.26.0               # Exact version
@@ -356,12 +333,18 @@ if [ -z "$PLATFORM" ]; then
     PY_VER_MAJOR=$(echo "$PYTHON_VERSION" | cut -d. -f1)
     PY_VER_MINOR=$(echo "$PYTHON_VERSION" | cut -d. -f2)
     
-    # Default to manylinux2014 (Amazon Linux 2)
-    PLATFORM_PREFIX="manylinux2014"
-    
-    # Legacy: We previously checked for AL2023 (manylinux_2_28) here, but forcing it
-    # causes issues with packages like NumPy that publish manylinux2014 or manylinux_2_17 wheels.
-    # Since AL2023 is backward compatible with manylinux2014, we stick to that for max compatibility.
+    # 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"
@@ -393,9 +376,13 @@ if [ ${#INSTALL_OPTS[@]} -gt 0 ]; then
     # 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"
-    pip install "${PKG_ARRAY[@]}" "${INSTALL_OPTS[@]}" --target "$SITE_PACKAGES"
+    CMD=(pip install "${PKG_ARRAY[@]}" "${INSTALL_OPTS[@]}" --target "$SITE_PACKAGES")
+    echo "  Running: ${CMD[*]}"
+    "${CMD[@]}"
 else
-    pip install "${PKG_ARRAY[@]}"
+    CMD=(pip install "${PKG_ARRAY[@]}")
+    echo "  Running: ${CMD[*]}"
+    "${CMD[@]}"
 fi
 
 # Count packages from command argument

package/scripts/create_wheel_layer.sh

@@ -12,10 +12,19 @@ set -u
 WHEEL_FILE=""
 PACKAGES=""
 LAYER_NAME=""
-PYTHON_VERSION="3.12"
-PLATFORM="manylinux2014_x86_64"
+# 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="cp312"  # Default ABI tag
+ABI=""  # Will be calculated
 
 # Colors
 RED='\033[0;31m'
@@ -67,6 +76,7 @@ while [[ $# -gt 0 ]]; do
             ;;
         --python-version)
             if [[ -n "${2:-}" && "${2:-}" != -* ]]; then
+                USER_PYTHON_VERSION="$2"
                 PYTHON_VERSION="$2"
                 shift 2
             else
@@ -75,20 +85,23 @@ while [[ $# -gt 0 ]]; do
             fi
             ;;
         --python-version=*)
+            USER_PYTHON_VERSION="${1#*=}"
             PYTHON_VERSION="${1#*=}"
             shift
             ;;
-        --platform)
+        --architecture|-a)
             if [[ -n "${2:-}" && "${2:-}" != -* ]]; then
-                PLATFORM="$2"
+                USER_ARCHITECTURE="$2"
+                ARCHITECTURE="$2"
                 shift 2
             else
                 printf "${RED}Error: $1 requires an argument${NC}\n"
                 exit 1
             fi
             ;;
-        --platform=*)
-            PLATFORM="${1#*=}"
+        --architecture=*)
+            USER_ARCHITECTURE="${1#*=}"
+            ARCHITECTURE="${1#*=}"
             shift
             ;;
         -h|--help)
@@ -100,28 +113,18 @@ Options:
   -i, --packages       Additional packages (comma or space separated)
   -n, --name           Output zip filename
   --python-version     Target Python version (default: 3.12)
-  --platform           Target platform (default: manylinux2014_x86_64)
-
-Supported Platforms:
-  manylinux2014_x86_64    # Amazon Linux 2, RHEL 7+ (older)
-  manylinux2014_aarch64   # ARM64 architecture
-  manylinux_2_28_x86_64   # Amazon Linux 2023, RHEL 8+ (newer)
-  manylinux_2_28_aarch64  # ARM64 with newer glibc
-  linux_x86_64            # Generic Linux
-  linux_aarch64           # Generic ARM64 Linux
+  -a, --architecture   Target architecture (x86_64, arm64)
 
-Python Version Support:
-  3.8, 3.9, 3.10, 3.11, 3.12, 3.13, 3.14
+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)
-  ./create_wheel_layer.sh -w mypackage.whl --python-version=3.12 --platform=manylinux2014_x86_64
+  # Build for Amazon Linux 2 (Python 3.12, x86_64)
+  ./create_wheel_layer.sh -w mypackage.whl --python-version=3.12
 
-  # Build for Amazon Linux 2023 (Python 3.13)
-  ./create_wheel_layer.sh -w mypackage.whl --python-version=3.13 --platform=manylinux_2_28_x86_64
-
-  # Build with additional packages for ARM64
-  ./create_wheel_layer.sh -w mypackage.whl -i "numpy,pandas" --platform=manylinux_2_28_aarch64
+  # Build for ARM64
+  ./create_wheel_layer.sh -w mypackage.whl -a arm64
 EOF
             exit 0
             ;;
@@ -137,15 +140,233 @@ 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
 
-# Determine ABI tag based on Python version
-PY_MAJOR_MINOR=$(echo "$PYTHON_VERSION" | sed 's/\([0-9]\+\)\.\([0-9]\+\).*/\1\2/')
-ABI="cp${PY_MAJOR_MINOR}"
+# ------------------------------------------------------------------
+# 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)
@@ -166,14 +387,15 @@ printf "Wheel: $WHEEL_FILE\n"
 if [ -n "$PACKAGES" ]; then
     printf "Extra Packages: $PACKAGES\n"
 fi
-printf "Platform: $PLATFORM\n"
-printf "Python: $PYTHON_VERSION\n"
+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" "install" "$WHEEL_FILE")
+CMD=("$PIP_EXE" "install" "$WHEEL_FILE")
 
 if [ -n "$PACKAGES" ]; then
     # Replace commas with spaces
@@ -184,7 +406,14 @@ if [ -n "$PACKAGES" ]; then
 fi
 
 CMD+=("--target" "$LAYER_DIR/python")
-CMD+=("--platform" "$PLATFORM")
+
+# 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")
@@ -208,10 +437,18 @@ find "$LAYER_DIR" -type d -name "*.dist-info" -exec rm -rf {} +
 # Zip
 printf "${GREEN}Zipping to $LAYER_NAME...${NC}\n"
 cd "$LAYER_DIR"
-if zip -r "$ORIGINAL_DIR/$LAYER_NAME" python > /dev/null; then
+
+# 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${NC}\n"
+    printf "${RED}Error creating zip file at $ZIP_DEST${NC}\n"
     cd "$ORIGINAL_DIR"
     rm -rf "$LAYER_DIR"
     exit 1

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.1.3" # Fallback version
+$Version = "2.2.0" # Fallback version
 
 # Colors for output
 $Green = "Green"