To_DEB.sh

#!/bin/bash

# Bash to DEB Package Converter
# This script converts a bash script into a Debian package

set -euo pipefail  # Exit on error, unset variables, and pipe failures

# Default values
SCRIPT_FILE=""
PACKAGE_NAME=""
SCRIPT_NAME=""  # New variable for the actual script name
VERSION="1.0.0"
DESCRIPTION="Converted bash script"
MAINTAINER=""
DEPENDS=""
INSTALL_PATH="/usr/local/bin"
ARCHITECTURE="all"
SECTION="utils"
PRIORITY="optional"
OUTPUT_DIR="./deb_packages"
TEMP_DIR="/tmp/deb_build_$$"

# Color codes for output
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
NC='\033[0m' # No Color

# Function to display usage
usage() {
    cat << EOF
Usage: $0 -s SCRIPT_FILE -n PACKAGE_NAME [OPTIONS]

Required options:
  -s, --script FILE        Path to the bash script to convert
  -n, --name NAME          Package name (lowercase, no spaces)

Optional options:
  -v, --version VERSION    Package version (default: 1.0.0)
  -d, --description DESC   Package description
  -m, --maintainer EMAIL   Maintainer name and email (e.g., "Name <email>")
  -D, --depends DEPS       Dependencies (comma-separated, e.g., "curl,wget")
  -p, --path PATH          Install path (default: /usr/local/bin)
  -a, --arch ARCH          Architecture (default: all)
  -o, --output DIR         Output directory (default: ./deb_packages)
  -S, --script-name NAME   Name for the installed script (default: derived from package name)
  -h, --help               Show this help message

Example:
  $0 -s my_script.sh -n my-package -v 1.2.3 -d 'My awesome script'
  $0 -s fakeap.sh -n fakeap-tool -S fakeap
EOF
}

# Function to log messages
log() {
    local level=$1
    shift
    local message="$*"
    
    case $level in
        "INFO")
            echo -e "${BLUE}[INFO]${NC} $message"
            ;;
        "SUCCESS")
            echo -e "${GREEN}[SUCCESS]${NC} $message"
            ;;
        "WARNING")
            echo -e "${YELLOW}[WARNING]${NC} $message"
            ;;
        "ERROR")
            echo -e "${RED}[ERROR]${NC} $message" >&2
            ;;
    esac
}

# Function to validate package name
validate_package_name() {
    local name=$1
    # Debian policy: numbers, lowercase letters, +, -, .
    # Must start with an alphanumeric character.
    if [[ ! $name =~ ^[a-z0-9][a-z0-9+.-]*$ ]]; then
        log "ERROR" "Invalid package name: '$name'"
        log "INFO" "Package names must differ strictly by case, start with an alphanumeric character, and contain only lowercase letters, digits, plus (+), minus (-), and periods (.)."
        return 1
    fi
    return 0
}

# Function to derive script name from package name
derive_script_name() {
    local pkg_name=$1
    local clean_name="$pkg_name"
    
    clean_name="${clean_name%.deb}"
    clean_name="${clean_name%-tool}"
    clean_name="${clean_name%-script}"
    clean_name="${clean_name%-app}"
    
    echo "$clean_name"
}

# Function to attempt to guess maintainer info
guess_maintainer() {
    local git_name=""
    local git_email=""
    
    if command -v git &> /dev/null; then
        git_name=$(git config user.name || true)
        git_email=$(git config user.email || true)
    fi

    if [[ -n "$git_name" ]] && [[ -n "$git_email" ]]; then
        echo "$git_name <$git_email>"
    else
        echo "$(whoami) <$(whoami)@$(hostname)>"
    fi
}

# Function to check if required tools are installed
check_dependencies() {
    local missing_tools=()
    
    for tool in dpkg-deb fakeroot; do
        if ! command -v "$tool" &> /dev/null; then
            missing_tools+=("$tool")
        fi
    done
    
    if [ ${#missing_tools[@]} -ne 0 ]; then
        log "ERROR" "Missing required tools: ${missing_tools[*]}"
        log "INFO" "Install with: sudo apt-get install dpkg-dev fakeroot"
        return 1
    fi
    
    return 0
}

# Function to calculate installed size (in KB)
calculate_installed_size() {
    local build_dir=$1
    # du -sk returns size in blocks (usually 1KB blocks)
    # Using --exclude to avoid counting DEBIAN overhead if needed, but strict control usually includes everything in data.tar.gz
    # However, strictly speaking, Installed-Size is the size of the unpacked files.
    # We will approximate it by du -sk of the whole build dir excluding DEBIAN.
    du -sk --exclude="$build_dir/DEBIAN" "$build_dir" | awk '{print $1}'
}

# Function to create directories
create_directories() {
    local build_dir=$1
    mkdir -p "$build_dir/DEBIAN"
    mkdir -p "$build_dir$INSTALL_PATH"
}

# Function to copy and prepare the script
prepare_script() {
    local build_dir=$1
    local target_script="$build_dir$INSTALL_PATH/$SCRIPT_NAME"
    
    # Copy the script
    if ! cp "$SCRIPT_FILE" "$target_script"; then
        log "ERROR" "Failed to copy script file"
        return 1
    fi
    
    # Make executable (755)
    chmod 755 "$target_script"
    
    # Check shebang
    if ! head -n 1 "$target_script" | grep -q "^#!"; then
        log "WARNING" "Script missing shebang. Prepending '#!/bin/bash'"
        sed -i '1i#!/bin/bash' "$target_script"
    fi
}

# Function to finalize control file and md5sums
finalize_debian_metadata() {
    local build_dir=$1
    local debian_dir="$build_dir/DEBIAN"

    # Calculate size
    local installed_size
    installed_size=$(calculate_installed_size "$build_dir")
    
    # Create control file
    cat > "$debian_dir/control" << EOF
Package: $PACKAGE_NAME
Version: $VERSION
Section: $SECTION
Priority: $PRIORITY
Architecture: $ARCHITECTURE
Maintainer: $MAINTAINER
Installed-Size: $installed_size
Description: $DESCRIPTION
EOF

    if [ -n "$DEPENDS" ]; then
        echo "Depends: $DEPENDS" >> "$debian_dir/control"
    fi
    
    # Generate md5sums
    log "INFO" "Generating md5sums..."
    pushd "$build_dir" > /dev/null
    find . -type f ! -path "./DEBIAN/*" -exec md5sum {} + > "DEBIAN/md5sums"
    chmod 644 "DEBIAN/md5sums"
    popd > /dev/null
}

create_maintainer_scripts() {
    local build_dir=$1
    local debian_dir="$build_dir/DEBIAN"
    # Basic maintainer scripts if needed.
    # Currently just logging, as dpkg handles permissions.
}

# Function to build the package
build_package() {
    local build_dir=$1
    local output_file="$OUTPUT_DIR/${PACKAGE_NAME}_${VERSION}_${ARCHITECTURE}.deb"
    
    mkdir -p "$OUTPUT_DIR"
    
    log "INFO" "Building package..."
    if fakeroot dpkg-deb --build "$build_dir" "$output_file"; then
        log "SUCCESS" "Package created: $output_file"
        log "INFO" "Package Info:"
        dpkg-deb --info "$output_file"
        
        return 0
    else
        log "ERROR" "Failed to build package"
        return 1
    fi
}

cleanup() {
    if [ -d "$TEMP_DIR" ]; then
        rm -rf "$TEMP_DIR"
    fi
}

trap cleanup EXIT

# Parse arguments
while [[ $# -gt 0 ]]; do
    case $1 in
        -s|--script) SCRIPT_FILE="$2"; shift 2 ;;
        -n|--name) PACKAGE_NAME="$2"; shift 2 ;;
        -v|--version) VERSION="$2"; shift 2 ;;
        -d|--description) DESCRIPTION="$2"; shift 2 ;;
        -m|--maintainer) MAINTAINER="$2"; shift 2 ;;
        -D|--depends) DEPENDS="$2"; shift 2 ;;
        -p|--path) INSTALL_PATH="$2"; shift 2 ;;
        -a|--arch) ARCHITECTURE="$2"; shift 2 ;;
        -o|--output) OUTPUT_DIR="$2"; shift 2 ;;
        -S|--script-name) SCRIPT_NAME="$2"; shift 2 ;;
        -h|--help) usage; exit 0 ;;
        *) log "ERROR" "Unknown option: $1"; usage; exit 1 ;;
    esac
done

# Validation
if [ -z "$SCRIPT_FILE" ] || [ -z "$PACKAGE_NAME" ]; then
    usage
    log "ERROR" "Missing required parameters (-s and -n)"
    exit 1
fi

if [ ! -f "$SCRIPT_FILE" ]; then
    log "ERROR" "Script file not found: $SCRIPT_FILE"
    exit 1
fi

if [ -z "$SCRIPT_NAME" ]; then
    SCRIPT_NAME=$(derive_script_name "$PACKAGE_NAME")
fi

if [ -z "$MAINTAINER" ]; then
    MAINTAINER=$(guess_maintainer)
fi

if ! validate_package_name "$PACKAGE_NAME"; then
    exit 1
fi

if ! check_dependencies; then
    exit 1
fi

log "INFO" "Configuration:"
log "INFO" "  Script: $SCRIPT_FILE"
log "INFO" "  Package: $PACKAGE_NAME"
log "INFO" "  Version: $VERSION"
log "INFO" "  Output: $OUTPUT_DIR"
log "INFO" "  Maintainer: $MAINTAINER"

# Create Build Directory
mkdir -p "$TEMP_DIR"

# 1. Structure (Create dirs)
create_directories "$TEMP_DIR"

# 2. Prepare Script (Copy files)
prepare_script "$TEMP_DIR"

# 3. Finalize Metadata (Control file, md5sums)
finalize_debian_metadata "$TEMP_DIR"

# 4. Build
if ! build_package "$TEMP_DIR"; then
    exit 1
fi