[Script request] Stream Master LXC

[PacketPalantir]

Application Name

Stream Master

Website

https://github.com/SenexCrenshaw/StreamMaster

Description

Stream Master is the only HDHR solution I found that works flawlessly with Plex. It's currently Docker-only, but it would be nice to have in an LXC.

Due Diligence

• I have searched existing scripts and found no duplicates.
• I have searched existing discussions and found no duplicate requests.
• This is not a game-related request.

[X5-176]

I second this I would like an lxc of StreamMaster, Threadfin has been really unstable for me and I have to restart it or delete and re-add my playlist too many times.

Also the StreamMaster project has moved to: https://github.com/carlreid/StreamMaster

[Patrick010]

I've managed to create this script using ChatGTP. I had it analyse the installation instructions and Docker files on https://github.com/carlreid/StreamMaster

The script is undoubtedly messy, but it runs for me. The Frontend GUI is shown and there are no errors in the logs.
I haven't tried any of the functionality yet, maybe one of you guys can check if it works as it should.

#!/bin/bash

set -e

echo "🔧 Updating system and installing dependencies..."
apt update && apt upgrade -y
apt install -y curl wget gnupg2 ca-certificates apt-transport-https software-properties-common lsb-release net-tools unzip sudo git build-essential libssl-dev

echo "📦 Installing .NET 9 SDK..."
mkdir -p /opt/dotnet
cd /opt/dotnet
wget -q https://builds.dotnet.microsoft.com/dotnet/Sdk/9.0.203/dotnet-sdk-9.0.203-linux-x64.tar.gz
tar -xvf dotnet-sdk-9.0.203-linux-x64.tar.gz
ln -sf /opt/dotnet/dotnet /usr/bin/dotnet

echo "📦 Installing Node.js 20..."
curl -fsSL https://deb.nodesource.com/setup_20.x | bash -
apt install -y nodejs

echo "🐘 Installing and configuring PostgreSQL..."
apt install -y postgresql postgresql-contrib
systemctl enable --now postgresql

# Create PostgreSQL user and database if not already existing
sudo -u postgres psql -c "SELECT 1 FROM pg_roles WHERE rolname='postgres'" | grep -q 1 || sudo -u postgres psql -c "CREATE USER postgres WITH PASSWORD 'sm123';"
sudo -u postgres psql -c "SELECT 1 FROM pg_database WHERE datname='StreamMaster'" | grep -q 1 || sudo -u postgres psql -c "CREATE DATABASE StreamMaster OWNER postgres;"

echo "📥 Cloning StreamMaster repo..."
cd /opt
git clone https://github.com/carlreid/StreamMaster.git
cd /opt/StreamMaster

echo "🔨 Publishing backend..."
echo "🔧 Updating SixLabors.ImageSharp version from 3.1.6 to 3.1.7..."

# Update StreamMaster.Streams.csproj
sed -i 's|<PackageReference Include="SixLabors.ImageSharp" Version="3.1.6" />|<PackageReference Include="SixLabors.ImageSharp" Version="3.1.7" />|' /opt/StreamMaster/src/StreamMaster.Streams/StreamMaster.Streams.csproj

# Update StreamMaster.SchedulesDirect.csproj
sed -i 's|<PackageReference Include="SixLabors.ImageSharp" Version="3.1.6" />|<PackageReference Include="SixLabors.ImageSharp" Version="3.1.7" />|' /opt/StreamMaster/src/StreamMaster.SchedulesDirect/StreamMaster.SchedulesDirect.csproj

echo "✅ ImageSharp version updated successfully."

dotnet publish /opt/StreamMaster/src/StreamMaster.API/StreamMaster.API.csproj -c Release -o /opt/StreamMaster/publish

echo "📦 Installing dotnet-ef tool..."
dotnet tool install --global dotnet-ef

# Ensure .NET SDK is in the PATH
export DOTNET_ROOT=/opt/dotnet
export PATH=$PATH:$DOTNET_ROOT

# Ensure dotnet-ef is available
export PATH="$PATH:/root/.dotnet/tools"

# Install the Microsoft.EntityFrameworkCore.Design package
echo "📦 Installing Microsoft.EntityFrameworkCore.Design..."
cd /opt/StreamMaster/src/StreamMaster.API
dotnet add package Microsoft.EntityFrameworkCore.Design --version 9.0.4

# Restore .NET tools, including dotnet-ef
echo "🔧 Restoring .NET tools..."
dotnet tool restore

# Restore the dependencies
echo "🔧 Restoring dependencies..."
dotnet restore /opt/StreamMaster/src/StreamMaster.API/StreamMaster.API.csproj

# Apply database migrations
echo "🔨 Applying database migrations..."
dotnet ef database update --project /opt/StreamMaster/src/StreamMaster.API/StreamMaster.API.csproj

echo "🎨 Building frontend..."
cd /opt/StreamMaster/src/StreamMaster.WebUI
npm install
npm run build

echo "📁 Copying frontend to publish directory..."
mkdir -p /opt/StreamMaster/publish/wwwroot
cp -r dist/* /opt/StreamMaster/publish/wwwroot/

echo "🧩 Creating systemd service..."
cat <<EOF > /etc/systemd/system/streammaster.service
[Unit]
Description=StreamMaster Service
After=network.target postgresql.service
Requires=postgresql.service

[Service]
WorkingDirectory=/opt/StreamMaster/publish
ExecStart=/usr/bin/dotnet StreamMaster.API.dll
Restart=always
RestartSec=10
User=root
Environment=POSTGRES_HOST=127.0.0.1
Environment=POSTGRES_USER=postgres
Environment=POSTGRES_PASSWORD=sm123
Environment=POSTGRES_DB=StreamMaster
Environment=DEFAULT_PORT=7095
Environment=DEFAULT_SSL_PORT=7096

[Install]
WantedBy=multi-user.target
EOF

systemctl daemon-reexec
systemctl daemon-reload
systemctl enable --now streammaster

echo "✅ Installation complete."
echo "🌐 Access StreamMaster at: http://$(hostname -I | awk '{print $1}'):7095"

[Patrick010]

It works, but am getting way more buffering than with xTeVe or Threadfin. Is that a setting in StreamMaster?

[Patrick010]

Other thing is the 4 scripts used in the docker setup. I'm trying to understand what i.e. entrypoint.sh and evt.sh are for and if they play a rol in the workings of SM itself. Or are they used only once to set everything up
It came up with this:

Analysis of the Scripts

After analyzing the 4 scripts, here's how they interact and what they do:

Script Relationships

entrypoint.sh is the main script that orchestrates everything. It:

    Sources env.sh for environment configuration

    Uses functions from docker-entrypoint.sh for PostgreSQL setup

    Potentially calls docker-ensure-initdb.sh for database initialization

env.sh provides environment variable configuration and is sourced by entrypoint.sh

docker-entrypoint.sh is the standard PostgreSQL Docker entrypoint that provides core database initialization functions

docker-ensure-initdb.sh is a specialized wrapper around docker-entrypoint.sh that ensures database initialization

Consolidated Script

Here's a single bash script that combines all the functionality:

#!/bin/bash
set -Eeuo pipefail

# ========== Environment Configuration (from env.sh) ==========
default_email="[email protected]"
default_password="sm123"
default_dbuser="postgres"
default_dbpassword="sm123"
default_db="StreamMaster"
default_host="127.0.0.1"
default_port=7095
default_ssl_port=7096
default_set_perms=1
default_base_url=''

# Handle credential files
if [ -f "${POSTGRES_USER_FILE:-}" ]; then
    export POSTGRES_USER=$(cat "${POSTGRES_USER_FILE}")
else
    export POSTGRES_USER="${POSTGRES_USER:-$default_dbuser}"
fi
unset POSTGRES_USER_FILE 2>/dev/null || true

if [ -f "${POSTGRES_PASSWORD_FILE:-}" ]; then
    export POSTGRES_PASSWORD=$(cat "${POSTGRES_PASSWORD_FILE}")
else
    export POSTGRES_PASSWORD="${POSTGRES_PASSWORD:-$default_dbpassword}"
fi
unset POSTGRES_PASSWORD_FILE 2>/dev/null || true

# Set and export environment variables
export PGADMIN_SETUP_EMAIL="${PGADMIN_SETUP_EMAIL:-$default_email}"
export PGADMIN_SETUP_PASSWORD="${PGADMIN_SETUP_PASSWORD:-$default_password}"
export PGADMIN_PLATFORM_TYPE=debian
export PGDATA=/config/DB
export POSTGRES_HOST="${POSTGRES_HOST:-$default_host}"
export POSTGRES_DB="${POSTGRES_DB:-$default_db}"
export POSTGRES_SET_PERMS="${POSTGRES_SET_PERMS:-$default_set_perms}"
export DEFAULT_PORT="${DEFAULT_PORT:-$default_port}"
export DEFAULT_SSL_PORT="${DEFAULT_SSL_PORT:-$default_ssl_port}"

BASE_URL="${BASE_URL:-$default_base_url}"
if [[ ! $BASE_URL == /* ]]; then
    BASE_URL="/$BASE_URL"
fi
BASE_URL="${BASE_URL%/}"
export BASE_URL

# Function to determine if host is local
is_local() {
    [[ "$1" == "127.0.0.1" || "$1" == "localhost" ]] && echo "1" || echo "0"
}
export POSTGRES_ISLOCAL=$(is_local "$POSTGRES_HOST")

# Backup and restore configurations
export PATH=$PATH:/usr/lib/postgresql/15/bin
export BACKUP_DIR=/config/Backups
export RESTORE_DIR=/config/Restore

# ========== Docker Entrypoint Functions (from docker-entrypoint.sh) ==========
file_env() {
    local var="$1"
    local fileVar="${var}_FILE"
    local def="${2:-}"
    if [ "${!var:-}" ] && [ "${!fileVar:-}" ]; then
        printf >&2 'error: both %s and %s are set (but are exclusive)\n' "$var" "$fileVar"
        exit 1
    fi
    local val="$def"
    if [ "${!var:-}" ]; then
        val="${!var}"
    elif [ "${!fileVar:-}" ]; then
        val="$(< "${!fileVar}")"
    fi
    export "$var"="$val"
    unset "$fileVar"
}

_is_sourced() {
    [ "${#FUNCNAME[@]}" -ge 2 ] \
        && [ "${FUNCNAME[0]}" = '_is_sourced' ] \
        && [ "${FUNCNAME[1]}" = 'source' ]
}

docker_create_db_directories() {
    local user; user="$(id -u)"

    mkdir -p "$PGDATA"
    chmod 00700 "$PGDATA" || :

    mkdir -p /var/run/postgresql || :
    chmod 03775 /var/run/postgresql || :

    if [ -n "${POSTGRES_INITDB_WALDIR:-}" ]; then
        mkdir -p "$POSTGRES_INITDB_WALDIR"
        if [ "$user" = '0' ]; then
            find "$POSTGRES_INITDB_WALDIR" \! -user postgres -exec chown postgres '{}' +
        fi
        chmod 700 "$POSTGRES_INITDB_WALDIR"
    fi

    if [ "$user" = '0' ]; then
        find "$PGDATA" \! -user postgres -exec chown postgres '{}' +
        find /var/run/postgresql \! -user postgres -exec chown postgres '{}' +
    fi
}

docker_init_database_dir() {
    local uid; uid="$(id -u)"
    if ! getent passwd "$uid" &> /dev/null; then
        local wrapper
        for wrapper in {/usr,}/lib{/*,}/libnss_wrapper.so; do
            if [ -s "$wrapper" ]; then
                NSS_WRAPPER_PASSWD="$(mktemp)"
                NSS_WRAPPER_GROUP="$(mktemp)"
                export LD_PRELOAD="$wrapper" NSS_WRAPPER_PASSWD NSS_WRAPPER_GROUP
                local gid; gid="$(id -g)"
                printf 'postgres:x:%s:%s:PostgreSQL:%s:/bin/false\n' "$uid" "$gid" "$PGDATA" > "$NSS_WRAPPER_PASSWD"
                printf 'postgres:x:%s:\n' "$gid" > "$NSS_WRAPPER_GROUP"
                break
            fi
        done
    fi

    if [ -n "${POSTGRES_INITDB_WALDIR:-}" ]; then
        set -- --waldir "$POSTGRES_INITDB_WALDIR" "$@"
    fi

    eval 'initdb --username="$POSTGRES_USER" --pwfile=<(printf "%s\n" "$POSTGRES_PASSWORD") '"$POSTGRES_INITDB_ARGS"' "$@"'

    if [[ "${LD_PRELOAD:-}" == */libnss_wrapper.so ]]; then
        rm -f "$NSS_WRAPPER_PASSWD" "$NSS_WRAPPER_GROUP"
        unset LD_PRELOAD NSS_WRAPPER_PASSWD NSS_WRAPPER_GROUP
    fi
}

docker_verify_minimum_env() {
    case "${PG_MAJOR:-}" in
        13)
            if [ "${#POSTGRES_PASSWORD}" -ge 100 ]; then
                cat >&2 <<-'EOWARN'
                    WARNING: The supplied POSTGRES_PASSWORD is 100+ characters.
                      This will not work if used via PGPASSWORD with "psql".
                EOWARN
            fi
            ;;
    esac
    if [ -z "$POSTGRES_PASSWORD" ] && [ 'trust' != "$POSTGRES_HOST_AUTH_METHOD" ]; then
        cat >&2 <<-'EOE'
            Error: Database is uninitialized and superuser password is not specified.
                   You must specify POSTGRES_PASSWORD to a non-empty value for the
                   superuser. For example, "-e POSTGRES_PASSWORD=password" on "docker run".
        EOE
        exit 1
    fi
    if [ 'trust' = "$POSTGRES_HOST_AUTH_METHOD" ]; then
        cat >&2 <<-'EOWARN'
            WARNING: POSTGRES_HOST_AUTH_METHOD has been set to "trust". This will allow
                     anyone with access to the Postgres port to access your database without
                     a password, even if POSTGRES_PASSWORD is set.
        EOWARN
    fi
}

docker_process_init_files() {
    local psql=( docker_process_sql )
    printf '\n'
    local f
    for f; do
        case "$f" in
            *.sh)
                if [ -x "$f" ]; then
                    printf '%s: running %s\n' "$0" "$f"
                    "$f"
                else
                    printf '%s: sourcing %s\n' "$0" "$f"
                    . "$f"
                fi
                ;;
            *.sql)     printf '%s: running %s\n' "$0" "$f"; docker_process_sql -f "$f"; printf '\n' ;;
            *.sql.gz)  printf '%s: running %s\n' "$0" "$f"; gunzip -c "$f" | docker_process_sql; printf '\n' ;;
            *.sql.xz)  printf '%s: running %s\n' "$0" "$f"; xzcat "$f" | docker_process_sql; printf '\n' ;;
            *.sql.zst) printf '%s: running %s\n' "$0" "$f"; zstd -dc "$f" | docker_process_sql; printf '\n' ;;
            *)         printf '%s: ignoring %s\n' "$0" "$f" ;;
        esac
        printf '\n'
    done
}

docker_process_sql() {
    local query_runner=( psql -v ON_ERROR_STOP=1 --username "$POSTGRES_USER" --no-password --no-psqlrc )
    if [ -n "$POSTGRES_DB" ]; then
        query_runner+=( --dbname "$POSTGRES_DB" )
    fi
    PGHOST= PGHOSTADDR= "${query_runner[@]}" "$@"
}

docker_setup_db() {
    local dbAlreadyExists
    dbAlreadyExists="$(
        POSTGRES_DB= docker_process_sql --dbname postgres --set db="$POSTGRES_DB" --tuples-only <<-'EOSQL'
            SELECT 1 FROM pg_database WHERE datname = :'db' ;
        EOSQL
    )"
    if [ -z "$dbAlreadyExists" ]; then
        POSTGRES_DB= docker_process_sql --dbname postgres --set db="$POSTGRES_DB" <<-'EOSQL'
            CREATE DATABASE :"db" ;
        EOSQL
        printf '\n'
    fi
}

docker_setup_env() {
    file_env 'POSTGRES_PASSWORD'
    file_env 'POSTGRES_USER' 'postgres'
    file_env 'POSTGRES_DB' "$POSTGRES_USER"
    file_env 'POSTGRES_INITDB_ARGS'
    : "${POSTGRES_HOST_AUTH_METHOD:=}"

    declare -g DATABASE_ALREADY_EXISTS
    : "${DATABASE_ALREADY_EXISTS:=}"
    if [ -s "$PGDATA/PG_VERSION" ]; then
        DATABASE_ALREADY_EXISTS='true'
    fi
}

pg_setup_hba_conf() {
    if [ "$1" = 'postgres' ]; then
        shift
    fi
    local auth
    auth="$(postgres -C password_encryption "$@")"
    : "${POSTGRES_HOST_AUTH_METHOD:=$auth}"
    {
        printf '\n'
        if [ 'trust' = "$POSTGRES_HOST_AUTH_METHOD" ]; then
            printf '# warning trust is enabled for all connections\n'
            printf '# see https://www.postgresql.org/docs/17/auth-trust.html\n'
        fi
        printf 'host all all all %s\n' "$POSTGRES_HOST_AUTH_METHOD"
    } >> "$PGDATA/pg_hba.conf"
}

docker_temp_server_start() {
    if [ "$1" = 'postgres' ]; then
        shift
    fi
    set -- "$@" -c listen_addresses='' -p "${PGPORT:-5432}"
    PGUSER="${PGUSER:-$POSTGRES_USER}" \
    pg_ctl -D "$PGDATA" \
        -o "$(printf '%q ' "$@")" \
        -w start
}

docker_temp_server_stop() {
    PGUSER="${PGUSER:-postgres}" \
    pg_ctl -D "$PGDATA" -m fast -w stop
}

_pg_want_help() {
    local arg
    for arg; do
        case "$arg" in
            -'?'|--help|--describe-config|-V|--version)
                return 0
                ;;
        esac
    done
    return 1
}

_main() {
    if [ "${1:0:1}" = '-' ]; then
        set -- postgres "$@"
    fi

    if [ "$1" = 'postgres' ] && ! _pg_want_help "$@"; then
        docker_setup_env
        docker_create_db_directories
        if [ "$(id -u)" = '0' ]; then
            exec gosu postgres "$BASH_SOURCE" "$@"
        fi

        if [ -z "$DATABASE_ALREADY_EXISTS" ]; then
            docker_verify_minimum_env
            ls /docker-entrypoint-initdb.d/ > /dev/null
            docker_init_database_dir
            pg_setup_hba_conf "$@"
            export PGPASSWORD="${PGPASSWORD:-$POSTGRES_PASSWORD}"
            docker_temp_server_start "$@"
            docker_setup_db
            docker_process_init_files /docker-entrypoint-initdb.d/*
            docker_temp_server_stop
            unset PGPASSWORD
            cat <<-'EOM'
                PostgreSQL init process complete; ready for start up.
            EOM
        else
            cat <<-'EOM'
                PostgreSQL Database directory appears to contain a database; Skipping initialization
            EOM
        fi
    fi
    exec "$@"
}

# ========== Main Script Logic (from entrypoint.sh) ==========
user_name="nonRootUser"
group_name="nonRootGroup"

# Directories to create
declare -a dirs=(
    "/config/Cache"
    "/config/Logs"
    "/config/PlayLists/EPG"
    "/config/PlayLists/M3U"
    "/config/HLS"
    "/app/wwwroot"
    "$PGDATA"
    "$BACKUP_DIR"
    "$RESTORE_DIR"
)

# Validate PUID/PGID
if [ ! -z "$PUID" ]; then
    if [ "$PUID" -eq 0 ]; then
        echo "Running with root user (PUID=0)"
    elif [ "$PUID" -lt 1 ] || [ "$PUID" -gt 65534 ] 2>/dev/null; then
        echo "Invalid PUID: $PUID. Must be between 1 and 65534"
        exit 1
    fi
fi

if [ ! -z "$PGID" ]; then
    if [ "$PGID" -eq 0 ]; then
        echo "Running with root group (PGID=0)"
    elif [ "$PGID" -lt 1 ] || [ "$PGID" -gt 65534 ] 2>/dev/null; then
        echo "Invalid PGID: $PGID. Must be between 1 and 65534"
        exit 1
    fi
fi

# Create config.json
if ! echo "{
  \"defaultPort\": $DEFAULT_PORT,
  \"defaultBaseUrl\": \"${BASE_URL}\"
}" >/app/wwwroot/config.json; then
    echo "Failed to create config.json"
    exit 1
fi

# Safe directory creation function
safe_mkdir() {
    local dir="$1"
    mkdir -p "$dir" 2>/dev/null || echo "Failed to create directory $dir"
}

# Safe ownership change function
safe_chown() {
    local owner="$1"
    local path="$2"
    chown "$owner" "$path" 2>/dev/null || echo "Failed to change ownership of $path"
}

shopt -s nullglob

moveFilesAndDeleteDir() {
    local source_dir="$1"
    local destination_dir="$2"

    if [ -d "$source_dir" ]; then
        if [ ! -d "$destination_dir" ]; then
            mkdir -p "$destination_dir"
        fi

        local files=("$source_dir"/*)
        if [ -e "${files[0]}" ]; then
            if mv "$source_dir"/* "$destination_dir"/ 2>/dev/null; then
                echo "Files moved successfully from $source_dir to $destination_dir."
            else
                echo "Failed to move files from $source_dir to $destination_dir."
                return
            fi
        else
            echo "No files to move from $source_dir."
        fi

        if rmdir "$source_dir" 2>/dev/null; then
            echo "Source directory $source_dir removed."
        else
            echo "Failed to remove source directory $source_dir. It might not be empty."
        fi
    fi
}

check_files_ready_for_restore() {
    local file_found=1

    if [ ! -d "$RESTORE_DIR" ]; then
        echo "Restore path does not exist: $RESTORE_DIR"
        return 1
    fi

    local files=("$RESTORE_DIR"/backup_*.tar.gz)
    if [ ${#files[@]} -eq 0 ] || [ ! -e "${files[0]}" ]; then
        echo "No backup files found in $RESTORE_DIR."
        return 1
    fi

    for file in "${files[@]}"; do
        if [ -s "$file" ]; then
            echo "File is ready for restore: $(basename "$file")"
            file_found=0
            break
        else
            echo "Found an empty backup file: $(basename "$file")"
        fi
    done

    return $file_found
}

rename_directory() {
    local src="$1"
    local dest="$2"

    if [ ! -d "$src" ]; then
        return 1
    fi

    if [ "$src" = "$dest" ]; then
        return 1
    fi

    local temp_dest="${dest}.tmp"
    if [ -d "$dest" ] || [ -d "$temp_dest" ]; then
        return 1
    fi

    if mv "$src" "$temp_dest" && mv "$temp_dest" "$dest"; then
        echo "Directory renamed successfully from $src to $dest"
    else
        echo "Failed to rename directory from $src to $dest"
        rm -rf "$temp_dest" 2>/dev/null
        return 1
    fi
}

wait_for_postgres() {
    local host="$1"
    local port="$2"
    local max_attempts="$3"
    local wait_interval="$4"
    local attempt=0

    while [ $attempt -lt "$max_attempts" ]; do
        if pg_isready -h "$host" -p "$port" >/dev/null 2>&1; then
            echo "PostgreSQL is ready on $host:$port"
            return 0
        fi
        attempt=$((attempt + 1))
        echo "Attempt $attempt: PostgreSQL is not yet ready on $host:$port. Retrying in $wait_interval seconds..."
        sleep "$wait_interval"
    done

    echo "Error: PostgreSQL on $host:$port is not ready after $max_attempts attempts."
    return 1
}

# User/group setup
if [ "$PUID" -ne 0 ]; then
    if getent passwd "$PUID" >/dev/null 2>&1; then
        user_name=$(getent passwd "$PUID" | cut -d: -f1)
    else
        useradd --uid "$PUID" -K UID_MIN=10 --comment "nonRootUser" --shell /bin/bash nonRootUser || {
            echo "Failed to create user with PUID: $PUID"
            exit 1
        }
    fi
fi

if [ "$PGID" -ne 0 ]; then
    if getent group "$PGID" >/dev/null 2>&1; then
        group_name=$(getent group "$PGID" | cut -d: -f1)
    else
        addgroup --gid "$PGID" --force-badname "nonRootGroup" || {
            echo "Failed to create group with PGID: $PGID"
            exit 1
        }
    fi
fi

rm -rf /config/hls

# Create all required directories
for dir in "${dirs[@]}"; do
    if ! safe_mkdir "$dir"; then
        echo "Critical directory creation failed for: $dir"
        exit 1
    fi
done

rename_directory /config/settings /config/Settings
rename_directory /config/backups /config/Backups

# Create trap for temporary file cleanup
temp_script=$(mktemp)
trap 'rm -f "$temp_script"' EXIT

# Change ownership of the /app directory
if [ "$PUID" -ne 0 ] || [ "$PGID" -ne 0 ]; then
    if ! safe_chown "${PUID:-0}:${PGID:-0}" "/app"; then
        echo "Critical ownership change failed for: /app"
        exit 1
    fi

    # Handle /config directory permissions
    echo '#!/bin/sh' > "$temp_script"
    echo "chown -R ${PUID:-0}:${PGID:-0} \"\$1\"" >> "$temp_script"
    chmod +x "$temp_script"

    find /config -mindepth 1 -maxdepth 1 -type d \
        -not -path '/config/tv-logos' \
        -not -path '/config/DB' \
        -exec "$temp_script" {} \;

    safe_chown "${PUID:-0}:${PGID:-0}" '/config/tv-logos'
    safe_chown "${PUID:-0}:${PGID:-0}" "$BACKUP_DIR"
    safe_chown "${PUID:-0}:${PGID:-0}" "$RESTORE_DIR"
fi

# Set specific permissions for backup/restore directories
if ! chmod 775 "$BACKUP_DIR"; then
    echo "Failed to set permissions on $BACKUP_DIR"
    exit 1
fi
if ! chmod 775 "$RESTORE_DIR"; then
    echo "Failed to set permissions on $RESTORE_DIR"
    exit 1
fi

# Handle PostgreSQL permissions
if [ "$POSTGRES_ISLOCAL" -eq 1 ] && [ "$POSTGRES_SET_PERMS" -eq 1 ]; then
    safe_chown "postgres:postgres" "$PGDATA"
fi

# Print configuration
echo "Configuration:"
echo "--------------"
echo "HOST:"
echo "  Default Port: $DEFAULT_PORT"
echo "  Default SSL Port: $DEFAULT_SSL_PORT"
echo "PGADMIN:"
echo "  Platform Type: $PGADMIN_PLATFORM_TYPE"
echo "  Setup Email: $PGADMIN_SETUP_EMAIL"
echo "  Setup Password: ********"
echo "POSTGRES:"
echo "  User: $POSTGRES_USER"
echo "  Password: ********"
echo "  DB Name: $POSTGRES_DB"
echo "  Host: $POSTGRES_HOST"
echo "  Is DB Local: $POSTGRES_ISLOCAL"
echo "  Data Directory: $PGDATA"
echo "  Set Perms: $POSTGRES_SET_PERMS"
echo "OS:"
echo "  User: ${PUID:-0} Group: ${PGID:-0}"
echo "  User: postgres Group: postgres"
echo "  UID: $(id -u postgres) GID: $(id -g postgres)"

# Start PostgreSQL if local
if [ "$POSTGRES_ISLOCAL" -eq 1 ]; then
    trap 'pkill postgres' EXIT
    _main postgres &
    trap - EXIT
fi

# Wait for PostgreSQL and handle restore
if wait_for_postgres "$POSTGRES_HOST" "5432" "${POSTGRES_MAX_ATTEMPTS:-20}" "${POSTGRES_WAIT_INTERVAL:-5}"; then
    echo "Postgres is up"

    if check_files_ready_for_restore; then
        echo "WARNING: You are about to restore the database. This operation cannot be undone."
        echo "The restoration process will begin in 10 seconds. Press Ctrl+C to cancel."
        sleep 10
        echo "Initiating restoration process..."
        # Note: The restore.sh script is not included in the provided files
        /usr/local/bin/restore.sh
    fi
else
    echo "Error: PostgreSQL is not ready."
    exit 1
fi

moveFilesAndDeleteDir /config/DB/Backup "$BACKUP_DIR"

safe_chown "${PUID:-0}:${PGID:-0}" "$BACKUP_DIR"
safe_chown "${PUID:-0}:${PGID:-0}" "$RESTORE_DIR"

if [ "$PUID" -ne 0 ]; then
    if usermod -aG postgres "$user_name"; then
        echo "User $user_name added to group postgres successfully."
        if ! chmod -R 775 "$PGDATA"; then
            echo "Failed to set permissions on $PGDATA"
            exit 1
        fi
    else
        echo "Failed to add user $user_name to group postgres."
    fi
fi

# Execute the main application
if [ "$PUID" -ne 0 ] && [ "$PGID" -ne 0 ]; then
    echo "Running as $user_name:$group_name"
    exec gosu "$user_name:$group_name" "$@"
elif [ "$PUID" -ne 0 ]; then
    echo "Running as $user_name"
    exec gosu "$user_name" "$@"
elif [ "$PGID" -ne 0 ]; then
    echo "Running as :$group_name"
    exec gosu ":$group_name" "$@"
else
    echo "Running as root"
    exec "$@"
fi

Key Observations

**Order of Operations:**

    Environment setup first (from env.sh)

    PostgreSQL functions next (from docker-entrypoint.sh)

    Main application logic last (from entrypoint.sh)

**Important Dependencies:**

    The script assumes PostgreSQL binaries are in the PATH

    It requires root privileges for certain operations (user/group creation)

    The restore.sh script is referenced but not provided in the input files

**Case Sensitivity:**

    All directory paths and variable names maintain their original case

    The script handles case-sensitive directory renames (like /config/settings to /config/Settings)

**Error Handling:**

    The script uses set -Eeuo pipefail for strict error handling

    Includes safe_mkdir and safe_chown functions to handle permission issues gracefully

The consolidated script maintains all the functionality of the original scripts while ensuring proper execution order and handling all dependencies correctly.

The above might become a part of the first installation script, but not yet sure about the best approach. I am by no means a scripting expert.