#!/bin/bash

##

# KolosalCode Universal Installer

# Automatically detects OS and installs the appropriate package

#

# Usage:

# curl -fsSL https://raw.githubusercontent.com/KolosalAI/kolosal-cli/main/install.sh | bash

# or

# wget -qO- https://raw.githubusercontent.com/KolosalAI/kolosal-cli/main/install.sh | bash

##

set -e

# Version to install

VERSION="${VERSION:-0.1.3}"

PACKAGE_VERSION="0.1.3"

# GitHub release URLs

GITHUB_REPO="KolosalAI/kolosal-cli"

MACOS_PKG_URL="https://github.com/KolosalAI/kolosal-cli/releases/download/v0.1.2/KolosalCode-macos-signed.pkg"

LINUX_DEB_URL="https://github.com/${GITHUB_REPO}/releases/download/v${VERSION}/kolosal-code_${PACKAGE_VERSION}_amd64.deb"

LINUX_RPM_URL="https://github.com/${GITHUB_REPO}/releases/download/v${VERSION}/kolosal-code-${PACKAGE_VERSION}.x86_64.rpm"

# Colors for output

RED='\033[0;31m'

GREEN='\033[0;32m'

YELLOW='\033[1;33m'

BLUE='\033[0;34m'

BOLD='\033[1m'

NC='\033[0m' # No Color

# Print functions

print_info() {

echo -e "${BLUE}ℹ${NC} $1"

}

print_success() {

echo -e "${GREEN}✓${NC} $1"

}

print_warning() {

echo -e "${YELLOW}⚠${NC} $1"

}

print_error() {

echo -e "${RED}✗${NC} $1"

}

print_header() {

echo ""

echo -e "${BOLD}$1${NC}"

echo "================================"

}

# Detect OS

detect_os() {

local os_name=""

local os_arch=""

# Detect OS type

case "$(uname -s)" in

Darwin*)

os_name="macos"

;;

Linux*)

os_name="linux"

;;

*)

print_error "Unsupported operating system: $(uname -s)"

print_info "KolosalCode currently supports macOS and Linux"

exit 1

;;

esac

# Detect architecture

case "$(uname -m)" in

x86_64|amd64)

os_arch="amd64"

;;

arm64|aarch64)

os_arch="arm64"

;;

*)

print_warning "Unsupported architecture: $(uname -m)"

print_info "Attempting to install anyway..."

os_arch="amd64"

;;

esac

echo "${os_name}:${os_arch}"

}

# Check if running as root (for Linux)

check_root() {

if [ "$EUID" -ne 0 ] && [ "$1" = "linux" ]; then

print_error "This script must be run with sudo on Linux"

echo ""

echo "Please run:"

echo " curl -fsSL https://raw.githubusercontent.com/${GITHUB_REPO}/main/install.sh | sudo bash"

echo ""

echo "Or download and run manually:"

echo " wget https://raw.githubusercontent.com/${GITHUB_REPO}/main/install.sh"

echo " sudo bash install.sh"

exit 1

fi

}

# Download file

download_file() {

local url="$1"

local output="$2"

print_info "Downloading from: $url"

# Try curl first, then wget

if command -v curl &> /dev/null; then

curl -fsSL -o "$output" "$url" || {

print_error "Download failed"

return 1

}

elif command -v wget &> /dev/null; then

wget -q -O "$output" "$url" || {

print_error "Download failed"

return 1

}

else

print_error "Neither curl nor wget is available"

print_info "Please install curl or wget and try again"

return 1

fi

print_success "Download complete"

}

# Install on macOS

install_macos() {

print_header "Installing KolosalCode on macOS"

local tmp_dir=$(mktemp -d)

local pkg_file="${tmp_dir}/KolosalCode.pkg"

# Download the package

if ! download_file "$MACOS_PKG_URL" "$pkg_file"; then

print_error "Failed to download macOS package"

rm -rf "$tmp_dir"

exit 1

fi

# Verify the download

if [ ! -f "$pkg_file" ]; then

print_error "Package file not found after download"

rm -rf "$tmp_dir"

exit 1

fi

print_info "Package size: $(du -h "$pkg_file" | cut -f1)"

# Check signature

print_info "Verifying package signature..."

if pkgutil --check-signature "$pkg_file" &> /dev/null; then

print_success "Package signature verified"

else

print_warning "Package signature could not be verified"

print_info "This might happen if the package is not notarized"

read -p "Continue with installation? (y/n) " -n 1 -r

echo

if [[ ! $REPLY =~ ^[Yy]$ ]]; then

print_info "Installation cancelled"

rm -rf "$tmp_dir"

exit 0

fi

fi

# Install the package

print_info "Installing KolosalCode..."

print_info "You may be prompted for your password"

if sudo installer -pkg "$pkg_file" -target /; then

print_success "Installation complete!"

else

print_error "Installation failed"

rm -rf "$tmp_dir"

exit 1

fi

# Clean up

rm -rf "$tmp_dir"

# Verify installation

if command -v kolosal &> /dev/null; then

print_success "KolosalCode is now installed"

echo ""

print_info "Installed version: $(kolosal --version 2>&1 | head -1)"

print_info "Installed location: $(which kolosal)"

else

print_warning "Installation completed but 'kolosal' command not found in PATH"

print_info "You may need to add /usr/local/bin to your PATH"

print_info "Or restart your terminal"

fi

}

# Install .deb package (Debian/Ubuntu-based systems)

install_deb() {

local tmp_dir=$(mktemp -d)

local deb_file="${tmp_dir}/kolosal-code.deb"

# Download the package

if ! download_file "$LINUX_DEB_URL" "$deb_file"; then

print_error "Failed to download .deb package"

rm -rf "$tmp_dir"

exit 1

fi

# Verify the download

if [ ! -f "$deb_file" ]; then

print_error "Package file not found after download"

rm -rf "$tmp_dir"

exit 1

fi

print_info "Package size: $(du -h "$deb_file" | cut -f1)"

# Install the package

print_info "Installing KolosalCode..."

if dpkg -i "$deb_file" 2>&1 | tee /tmp/kolosal-install.log; then

print_success "Installation complete!"

else

print_warning "Installation had some warnings"

# Try to fix dependencies

print_info "Attempting to fix dependencies..."

if apt-get install -f -y; then

print_success "Dependencies fixed"

else

print_error "Could not fix dependencies automatically"

print_info "Please run: sudo apt-get install -f"

fi

fi

# Clean up

rm -rf "$tmp_dir"

}

# Install .rpm package (Red Hat/Fedora/CentOS-based systems)

install_rpm() {

local tmp_dir=$(mktemp -d)

local rpm_file="${tmp_dir}/kolosal-code.rpm"

# Download the package

if ! download_file "$LINUX_RPM_URL" "$rpm_file"; then

print_error "Failed to download .rpm package"

rm -rf "$tmp_dir"

exit 1

fi

# Verify the download

if [ ! -f "$rpm_file" ]; then

print_error "Package file not found after download"

rm -rf "$tmp_dir"

exit 1

fi

print_info "Package size: $(du -h "$rpm_file" | cut -f1)"

# Install the package

print_info "Installing KolosalCode..."

# Detect package manager

if command -v dnf &> /dev/null; then

# Fedora/RHEL 8+

if dnf install -y "$rpm_file" 2>&1 | tee /tmp/kolosal-install.log; then

print_success "Installation complete!"

else

print_error "Installation failed"

rm -rf "$tmp_dir"

exit 1

fi

elif command -v yum &> /dev/null; then

# CentOS/RHEL 7

if yum install -y "$rpm_file" 2>&1 | tee /tmp/kolosal-install.log; then

print_success "Installation complete!"

else

print_error "Installation failed"

rm -rf "$tmp_dir"

exit 1

fi

elif command -v zypper &> /dev/null; then

# OpenSUSE

if zypper install -y "$rpm_file" 2>&1 | tee /tmp/kolosal-install.log; then

print_success "Installation complete!"

else

print_error "Installation failed"

rm -rf "$tmp_dir"

exit 1

fi

else

# Fallback to rpm command

if rpm -ivh "$rpm_file" 2>&1 | tee /tmp/kolosal-install.log; then

print_success "Installation complete!"

else

print_error "Installation failed"

rm -rf "$tmp_dir"

exit 1

fi

fi

# Clean up

rm -rf "$tmp_dir"

}

# Install on Linux

install_linux() {

print_header "Installing KolosalCode on Linux"

# Detect Linux distribution

local distro=""

local distro_like=""

if [ -f /etc/os-release ]; then

. /etc/os-release

distro="$ID"

distro_like="$ID_LIKE"

elif [ -f /etc/debian_version ]; then

distro="debian"

distro_like="debian"

elif [ -f /etc/redhat-release ]; then

distro="rhel"

distro_like="rhel fedora"

else

print_warning "Could not detect Linux distribution"

distro="unknown"

fi

print_info "Detected distribution: $distro"

# Determine package format based on distribution

local use_rpm=false

# Check for RPM-based distributions

if [[ "$distro" == "rhel" || "$distro" == "centos" || "$distro" == "fedora" ||

"$distro" == "rocky" || "$distro" == "alma" || "$distro" == "almalinux" ||

"$distro" == "opensuse" || "$distro" == "opensuse-leap" || "$distro" == "opensuse-tumbleweed" ||

"$distro" == "sles" || "$distro" == "amzn" || "$distro" == "ol" ]]; then

use_rpm=true

elif [[ "$distro_like" == *"rhel"* || "$distro_like" == *"fedora"* || "$distro_like" == *"suse"* ]]; then

use_rpm=true

fi

# Check for DEB-based distributions

local use_deb=false

if [[ "$distro" == "debian" || "$distro" == "ubuntu" || "$distro" == "linuxmint" ||

"$distro" == "pop" || "$distro" == "elementary" || "$distro" == "kali" ||

"$distro" == "raspbian" || "$distro" == "zorin" ]]; then

use_deb=true

elif [[ "$distro_like" == *"debian"* || "$distro_like" == *"ubuntu"* ]]; then

use_deb=true

fi

# Install based on package format

if [ "$use_deb" = true ]; then

print_info "Using .deb package format"

install_deb

elif [ "$use_rpm" = true ]; then

print_info "Using .rpm package format"

install_rpm

else

print_error "Could not determine package format for distribution: $distro"

print_info "Supported formats:"

print_info " - .deb for Debian/Ubuntu-based systems"

print_info " - .rpm for Red Hat/Fedora/CentOS-based systems"

print_info ""

print_info "Download packages manually from:"

print_info " .deb: $LINUX_DEB_URL"

print_info " .rpm: $LINUX_RPM_URL"

exit 1

fi

# Verify installation

if command -v kolosal &> /dev/null; then

print_success "KolosalCode is now installed"

echo ""

print_info "Installed version: $(kolosal --version 2>&1 | head -1)"

print_info "Installed location: $(which kolosal)"

else

print_warning "Installation completed but 'kolosal' command not found in PATH"

print_info "Try running: hash -r"

print_info "Or restart your terminal"

fi

}

# Show usage instructions

show_usage() {

echo ""

print_header "Quick Start"

echo ""

echo "Try running:"

echo -e " ${BOLD}kolosal --help${NC}"

echo ""

echo "To check the version:"

echo -e " ${BOLD}kolosal --version${NC}"

echo ""

echo "For more information, visit:"

echo " https://github.com/${GITHUB_REPO}"

echo ""

}

# Uninstall function (for reference)

show_uninstall_info() {

echo ""

print_header "Uninstallation"

echo ""

if [ "$(uname -s)" = "Darwin" ]; then

echo "To uninstall on macOS:"

echo " sudo rm -rf /usr/local/kolosal-app"

echo " sudo rm /usr/local/bin/kolosal"

else

echo "To uninstall on Linux:"

echo " # For Debian/Ubuntu (.deb):"

echo " sudo apt remove kolosal-code"

echo " # or"

echo " sudo dpkg -r kolosal-code"

echo ""

echo " # For Red Hat/Fedora/CentOS (.rpm):"

echo " sudo dnf remove kolosal-code"

echo " # or"

echo " sudo yum remove kolosal-code"

echo " # or"

echo " sudo rpm -e kolosal-code"

fi

echo ""

}

# Main installation flow

main() {

print_header "KolosalCode Installer v${VERSION}"

echo ""

# Detect OS and architecture

print_info "Detecting operating system..."

local os_info=$(detect_os)

local os_name=$(echo "$os_info" | cut -d: -f1)

local os_arch=$(echo "$os_info" | cut -d: -f2)

print_success "Detected: $os_name ($os_arch)"

echo ""

# Check if already installed

if command -v kolosal &> /dev/null; then

local current_version=$(kolosal --version 2>&1 | head -1)

print_warning "KolosalCode is already installed"

print_info "Current version: $current_version"

echo ""

read -p "Do you want to reinstall/upgrade? (y/n) " -n 1 -r

echo

if [[ ! $REPLY =~ ^[Yy]$ ]]; then

print_info "Installation cancelled"

exit 0

fi

fi

# Install based on OS

case "$os_name" in

macos)

install_macos

;;

linux)

check_root "$os_name"

install_linux

;;

*)

print_error "Unsupported OS: $os_name"

exit 1

;;

esac

# Show usage instructions

show_usage

# Show uninstall info

if [ "${SHOW_UNINSTALL_INFO:-0}" = "1" ]; then

show_uninstall_info

fi

print_success "Installation completed successfully!"

}

# Run main function

main "$@"