Jasne 😄 jeśli chodzi o **Debiana 12**, to masz kilka fajnych programów do sprawdzania **wydajności systemu** (CPU, RAM, dysk, itp.):

### 🔧 Najprostsze (terminal)

**1. htop** – top, ale 100× lepszy

```bash
sudo apt install htop
htop
```

Pokazuje CPU, RAM, procesy – bardzo czytelnie.

**2. btop** – nowoczesny, kolorowy, „wow-efekt”

```bash
sudo apt install btop
btop
```

Super do ogólnego podglądu wydajności.

**3. neofetch** – info o systemie (nie wydajność, ale fajne)

```bash
sudo apt install neofetch
neofetch
```

### 🧪 Testy wydajności (benchmark)

**4. sysbench** – test CPU, RAM, dysku

```bash
sudo apt install sysbench
```

Przykłady:

```bash
sysbench cpu run
sysbench memory run
```

**5. stress / stress-ng** – test obciążeniowy

```bash
sudo apt install stress-ng
```

### 🖥️ Graficzne (GUI)

**6. GNOME System Monitor** (jeśli masz GNOME)
Zwykle już jest zainstalowany – szukaj: *Monitor systemu*

Albo:

```bash
sudo apt install gnome-system-monitor
```

---

Jeśli powiesz:

* czy używasz **terminala czy okienek**,
* i czy chcesz **tylko podgląd**, czy prawdziwe **testy wydajności**,

to podpowiem Ci dokładnie najlepszy zestaw pod Twoje potrzeby 👨‍💻🚀

Okej, wyjaśnijmy to krok po kroku 😄

Komenda:

```bash
sudo apt install gnome-system-monitor
```

### Co się dzieje:

1. **`sudo`** – uruchamiasz komendę jako administrator, bo instalacja programów wymaga uprawnień root.
2. **`apt`** – menedżer pakietów w Debianie (czyli program, który pobiera i instaluje inne programy).
3. **`install`** – mówisz `apt`, że chcesz zainstalować coś nowego.
4. **`gnome-system-monitor`** – to nazwa programu, który zostanie zainstalowany.

### Co robi **GNOME System Monitor**:

* To **graficzny menedżer zadań** dla Debiana (tak jak Menedżer zadań w Windowsie).
* Pozwala w **okienku** obserwować:

  * użycie CPU (procesora),
  * RAM (pamięci),
  * obciążenie dysku i sieci,
  * jakie procesy działają i ile zasobów używają.

💡 Po instalacji uruchamiasz go po prostu wpisując w terminalu:

```bash
gnome-system-monitor
```

albo szukasz w menu systemowym: *Monitor systemu*.

---

Jeśli chcesz, mogę Ci zrobić **krótką listę najważniejszych funkcji i trików** w GNOME System Monitor, żeby od razu wiedzieć, jak sprawdzić wydajność komputera. Chcesz, żebym to zrobił?

Super, Twój skrypt już jest całkiem schludny i ma fajne animacje, ale można go **ulepszyć pod kątem czytelności, funkcji i wygody użytkownika**. Zrobiłem kilka zmian:

* Poprawiony **spinner** – działa poprawnie z funkcjami w tle.
* Dodany **kolorowy output** dla lepszego UX.
* Spinner teraz pokazuje „Pracuję...” dynamicznie, a po zakończeniu koloryzowany ✔.
* Funkcja `system_info` dodaje więcej szczegółów (CPU, RAM, dysk).
* Poprawione wyświetlanie IP – filtruje tylko IPv4.
* Dodany **czytelny menu loop z kolorami**.

Oto ulepszona wersja:

```bash
#!/bin/bash

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

# ===== ANIMACJE =====
spinner() {
    local pid=$!
    local spin='-\|/'
    local i=0
    tput civis
    while kill -0 $pid 2>/dev/null; do
        i=$(( (i+1) %4 ))
        printf "\r${YELLOW}[%c] Pracuję...${NC}" "${spin:$i:1}"
        sleep 0.1
    done
    printf "\r${GREEN}✔ Gotowe!        ${NC}\n"
    tput cnorm
}

type_text() {
    text="$1"
    for ((i=0; i<${#text}; i++)); do
        echo -n "${text:$i:1}"
        sleep 0.02
    done
    echo
}

pause() {
    read -rp "${BLUE}Naciśnij ENTER aby kontynuować...${NC}"
}

header() {
    clear
    echo -e "${BLUE}=====================================${NC}"
    type_text "   Debian System Helper  🚀"
    echo -e "${BLUE}=====================================${NC}"
    echo
}

update_system() {
    type_text "Aktualizacja systemu..."
    (sudo apt update && sudo apt upgrade -y) & spinner
}

clean_system() {
    type_text "Czyszczenie systemu..."
    (sudo apt autoremove -y && sudo apt autoclean) & spinner
}

system_info() {
    type_text "Pobieranie informacji o systemie..."
    sleep 0.3
    echo
    echo -e "${YELLOW}Host:${NC} $(hostname)"
    echo -e "${YELLOW}Uptime:${NC} $(uptime -p)"
    echo -e "${YELLOW}Kernel:${NC} $(uname -r)"
    echo -e "${YELLOW}CPU:${NC} $(lscpu | grep 'Model name' | sed 's/Model name: *//')"
    echo -e "${YELLOW}RAM:${NC} $(free -h | grep Mem | awk '{print $3 "/" $2}')"
    echo -e "${YELLOW}Dysk:${NC}"
    df -h /
}

show_ip() {
    type_text "Sprawdzanie adresów IP..."
    sleep 0.3
    ip -4 addr show | grep inet | awk '{print $2}'
}

boot_animation() {
    clear
    type_text "Uruchamianie system helpera..."
    sleep 0.4
    type_text "Ładowanie modułów..."
    sleep 0.4
    type_text "${GREEN}Gotowe!${NC}"
    sleep 0.6
}

# ===== START =====
boot_animation

while true; do
    header
    echo -e "${YELLOW}1)${NC} Aktualizuj system"
    echo -e "${YELLOW}2)${NC} Wyczyść system"
    echo -e "${YELLOW}3)${NC} Informacje o systemie"
    echo -e "${YELLOW}4)${NC} Pokaż IP"
    echo -e "${YELLOW}5)${NC} Wyjście"
    echo
    read -rp "Wybierz opcję: " choice

    case $choice in
        1) update_system; pause ;;
        2) clean_system; pause ;;
        3) system_info; pause ;;
        4) show_ip; pause ;;
        5)
            type_text "Zamykanie programu..."
            sleep 0.5
            echo -e "${GREEN}Do zobaczenia 😎${NC}"
            exit 0
            ;;
        *)
            type_text "${RED}Nieprawidłowa opcja!${NC}"
            sleep 1
            ;;
    esac
done
```

---

Jeśli chcesz, mogę zrobić jeszcze **wersję PRO**, która:

* **Pokazuje pasek postępu przy aktualizacji/oczyszczaniu**
* **Loguje wszystko do pliku**
* I ma **kolorowe menu dynamiczne** z podglądem CPU/RAM w czasie rzeczywistym

Chcesz, żebym taką zrobił?

Jasne, Mikołaj 😎 Zrobimy **super-profesjonalną wersję Twojego skryptu**, która:

1. Sprawdza, czy potrzebne programy są zainstalowane, a jeśli nie – instaluje je automatycznie.
2. Łączy wszystkie funkcje, które Ci wcześniej wymieniłem: `htop`, `btop`, `neofetch`, `sysbench`, `stress-ng`, `gnome-system-monitor`.
3. Dodaje **czytelny interfejs z kolorami, spinnerem i animacjami**.
4. Pozwala **zarządzać systemem, monitorować wydajność i uruchamiać testy benchmarków** w jednym miejscu.

Oto wersja „ultimate”:

```bash
#!/bin/bash

# ===== KOLORY =====
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
CYAN='\033[0;36m'
NC='\033[0m'

# ===== FUNKCJE =====

type_text() {
    text="$1"
    for ((i=0; i<${#text}; i++)); do
        echo -n "${text:$i:1}"
        sleep 0.02
    done
    echo
}

pause() {
    read -rp "${BLUE}Naciśnij ENTER aby kontynuować...${NC}"
}

spinner() {
    local pid=$!
    local spin='-\|/'
    local i=0
    tput civis
    while kill -0 $pid 2>/dev/null; do
        i=$(( (i+1) %4 ))
        printf "\r${YELLOW}[%c] Pracuję...${NC}" "${spin:$i:1}"
        sleep 0.1
    done
    printf "\r${GREEN}✔ Gotowe!        ${NC}\n"
    tput cnorm
}

header() {
    clear
    echo -e "${CYAN}=====================================${NC}"
    type_text "   Debian System Helper  🚀"
    echo -e "${CYAN}=====================================${NC}"
    echo
}

check_install() {
    for pkg in "$@"; do
        if ! command -v "$pkg" &>/dev/null; then
            type_text "${YELLOW}Instalowanie brakującego pakietu: $pkg...${NC}"
            sudo apt update && sudo apt install -y "$pkg"
        fi
    done
}

boot_animation() {
    clear
    type_text "Uruchamianie system helpera..."
    sleep 0.3
    type_text "Ładowanie modułów..."
    sleep 0.3
    type_text "${GREEN}Gotowe!${NC}"
    sleep 0.5
}

# ===== SYSTEM =====

update_system() {
    type_text "Aktualizacja systemu..."
    (sudo apt update && sudo apt upgrade -y) & spinner
}

clean_system() {
    type_text "Czyszczenie systemu..."
    (sudo apt autoremove -y && sudo apt autoclean) & spinner
}

system_info() {
    type_text "Pobieranie informacji o systemie..."
    echo
    echo -e "${YELLOW}Host:${NC} $(hostname)"
    echo -e "${YELLOW}Uptime:${NC} $(uptime -p)"
    echo -e "${YELLOW}Kernel:${NC} $(uname -r)"
    echo -e "${YELLOW}CPU:${NC} $(lscpu | grep 'Model name' | sed 's/Model name: *//')"
    echo -e "${YELLOW}RAM:${NC} $(free -h | grep Mem | awk '{print $3 "/" $2}')"
    echo -e "${YELLOW}Dysk:${NC}"
    df -h /
}

show_ip() {
    type_text "Sprawdzanie adresów IP..."
    ip -4 addr show | grep inet | awk '{print $2}'
}

run_htop() {
    check_install htop
    htop
}

run_btop() {
    check_install btop
    btop
}

run_neofetch() {
    check_install neofetch
    neofetch
}

run_sysbench_cpu() {
    check_install sysbench
    type_text "Test CPU (10k operacji)..."
    sysbench cpu --threads=2 --time=10 run
}

run_sysbench_mem() {
    check_install sysbench
    type_text "Test pamięci RAM..."
    sysbench memory --threads=2 --time=10 run
}

run_stress() {
    check_install stress-ng
    type_text "Test obciążeniowy: 2 minuty..."
    stress-ng --cpu 2 --io 1 --vm 1 --vm-bytes 128M --timeout 120s --metrics-brief
}

run_gnome_monitor() {
    check_install gnome-system-monitor
    type_text "Uruchamianie GNOME System Monitor..."
    gnome-system-monitor &
}

# ===== MENU =====
boot_animation

while true; do
    header
    echo -e "${YELLOW}1)${NC} Aktualizuj system"
    echo -e "${YELLOW}2)${NC} Wyczyść system"
    echo -e "${YELLOW}3)${NC} Informacje o systemie"
    echo -e "${YELLOW}4)${NC} Pokaż IP"
    echo -e "${YELLOW}5)${NC} Uruchom htop"
    echo -e "${YELLOW}6)${NC} Uruchom btop"
    echo -e "${YELLOW}7)${NC} Uruchom neofetch"
    echo -e "${YELLOW}8)${NC} Test CPU (sysbench)"
    echo -e "${YELLOW}9)${NC} Test RAM (sysbench)"
    echo -e "${YELLOW}10)${NC} Test obciążeniowy (stress-ng)"
    echo -e "${YELLOW}11)${NC} GNOME System Monitor"
    echo -e "${YELLOW}12)${NC} Wyjście"
    echo
    read -rp "Wybierz opcję: " choice

    case $choice in
        1) update_system; pause ;;
        2) clean_system; pause ;;
        3) system_info; pause ;;
        4) show_ip; pause ;;
        5) run_htop ;;
        6) run_btop ;;
        7) run_neofetch; pause ;;
        8) run_sysbench_cpu; pause ;;
        9) run_sysbench_mem; pause ;;
        10) run_stress; pause ;;
        11) run_gnome_monitor; pause ;;
        12)
            type_text "Zamykanie programu..."
            sleep 0.5
            echo -e "${GREEN}Do zobaczenia 😎${NC}"
            exit 0
            ;;
        *)
            type_text "${RED}Nieprawidłowa opcja!${NC}"
            sleep 1
            ;;
    esac
done
```

---

💡 **Co ten skrypt robi inaczej niż Twój poprzedni:**

* Sprawdza i **instaluje wszystkie potrzebne aplikacje automatycznie**, jeśli ich brakuje.
* Łączy **monitorowanie systemu, benchmarki i GUI narzędzia** w jednym menu.
* Kolorowy i przyjemny dla oka interfejs z animacjami i spinnerem.
* Możesz go traktować jak **kompletny „Debian Performance Suite”**.

---

Jeżeli chcesz, mogę zrobić jeszcze **wersję ultra-pro**, która:

* **wyświetla CPU/RAM w czasie rzeczywistym w menu głównym**
* **pokazuje pasek postępu dla update/clean**
* i zapisuje logi do pliku.

Chcesz, żebym zrobił taką wersję?


Ah, Mikołaj, to typowy problem z **uprawnieniami lub lokalizacją pliku** w Linuksie 😎. Sprawdźmy krok po kroku, żeby Twój `system-helper.sh` ruszył:

---

### 1️⃣ Sprawdź, czy plik istnieje w katalogu

W terminalu wpisz:

```bash
ls -l system-helper.sh
```

* Jeśli zobaczysz coś jak:

```
-rw-r--r-- 1 root root 5000 Jan 11 12:00 system-helper.sh
```

to plik jest tam, ale **nie jest wykonywalny**.

* Jeśli zobaczysz „No such file or directory” → plik **nie jest w katalogu**, musisz przejść do miejsca, gdzie go zapisałeś, np.:

```bash
cd /ścieżka/do/pliku
```

---

### 2️⃣ Nadaj plikowi prawa do wykonywania

```bash
chmod +x system-helper.sh
```

To sprawi, że Bash będzie mógł go uruchomić.

---

### 3️⃣ Uruchom plik poprawnie

```bash
./system-helper.sh
```

⚠ Ważne: **`./`** oznacza „uruchom plik z bieżącego katalogu”.

---

### 4️⃣ Sprawdź shebang (pierwsza linia pliku)

Twój plik zaczyna się od:

```bash
#!/bin/bash
```

To jest poprawnie, ale upewnij się, że Bash jest w `/bin/bash` (w Debianie tak jest).

Sprawdź:

```bash
which bash
```

* Powinno zwrócić `/bin/bash`
* Jeśli nie, popraw pierwszą linię w skrypcie na prawidłową ścieżkę.

---

💡 **Podsumowanie**: najczęstsza przyczyna błędu `nie można uruchomić: nie znaleziono wymaganego pliku` to **brak praw do wykonywania lub plik nie w tym katalogu**, a nie sam skrypt.

---

Jeżeli chcesz, mogę Ci napisać **jedną komendę, która od razu ustawi prawa i uruchomi skrypt**, żebyś nie musiał nic ręcznie robić.

Chcesz, żebym tak zrobił?


Super, skoro plik jest w tym samym katalogu, to wystarczy **tylko nadać mu prawa do wykonywania** i uruchomić 😎

W terminalu wpisz dokładnie:

```bash
chmod +x system-helper.sh
./system-helper.sh
```

* Pierwsza komenda sprawi, że Bash będzie mógł go uruchomić.
* Druga komenda faktycznie uruchomi skrypt.

💡 Jeśli dalej pojawi się **“nie znaleziono wymaganego pliku”**, to najczęstsze powody:

1. **Nieprawidłowy shebang** – pierwsza linia pliku powinna być dokładnie:

   ```bash
   #!/bin/bash
   ```

   Sprawdź:

   ```bash
   head -n 1 system-helper.sh
   ```
2. **Plik w formacie Windows (CRLF)** – jeśli był edytowany w Windowsie, Bash może nie rozpoznać końca linii. Wtedy naprawisz poleceniem:

   ```bash
   sudo apt install dos2unix
   dos2unix system-helper.sh
   ```

   i uruchamiasz ponownie:

   ```bash
   ./system-helper.sh
   ```

---

Jeżeli chcesz, mogę Ci od razu zrobić **skrypt sprawdzający i naprawiający format pliku oraz nadający prawa**, żeby działał od razu za pierwszym razem.

Chcesz, żebym to zrobił?

Super! 😎 Oto **krótki skrypt, który automatycznie**:

1. Sprawdza, czy plik istnieje w katalogu,
2. Naprawia format linii (CRLF → LF) jeśli był edytowany w Windowsie,
3. Nadaje prawa do wykonywania,
4. I od razu uruchamia Twój skrypt.

Zapisz to np. jako `run-system-helper.sh` w tym samym katalogu:

```bash
#!/bin/bash

SCRIPT="system-helper.sh"

# Sprawdź, czy plik istnieje
if [ ! -f "$SCRIPT" ]; then
    echo "❌ Plik $SCRIPT nie został znaleziony w bieżącym katalogu."
    exit 1
fi

# Napraw format linii, jeśli jest Windowsowy
if ! command -v dos2unix &>/dev/null; then
    echo "Instalacja dos2unix..."
    sudo apt update && sudo apt install -y dos2unix
fi
dos2unix "$SCRIPT"

# Nadaj prawa do wykonywania
chmod +x "$SCRIPT"

# Uruchom skrypt
echo "🚀 Uruchamianie $SCRIPT..."
./"$SCRIPT"
```

---

💡 **Jak używać:**

1. Zapisz powyższy plik w tym samym katalogu co `system-helper.sh`.
2. Nadaj mu prawa do wykonywania:

   ```bash
   chmod +x run-system-helper.sh
   ```
3. Uruchom:

   ```bash
   ./run-system-helper.sh
   ```

I wszystko powinno działać **od razu**, nawet jeśli Twój skrypt był zapisany w Windowsie lub nie miał praw do wykonywania.

---

Jeżeli chcesz, mogę zrobić jeszcze **wersję, która instaluje też wszystkie potrzebne aplikacje (htop, btop, sysbench, neofetch, stress-ng, gnome-system-monitor) automatycznie przed uruchomieniem skryptu** – wtedy masz kompletny setup jednym kliknięciem.

Chcesz, żebym taką zrobił?
Haha, jasne, Mikołaj 😎🚀 Skoro podoba Ci się pomysł „wszystko w jednym”, zrobimy **mega-profesjonalną wersję** Twojego helpera, który:

1. Sprawdza i **instaluje automatycznie wszystkie potrzebne narzędzia**:

   * `htop`, `btop` – monitorowanie w terminalu
   * `neofetch` – info o systemie
   * `sysbench` – test CPU/RAM
   * `stress-ng` – test obciążeniowy
   * `gnome-system-monitor` – GUI monitor systemu

2. Naprawia plik, jeśli jest w formacie Windows (CRLF).

3. Nadaje prawa do wykonywania.

4. Ma **kolorowy, czytelny interfejs z animacjami**.

5. Wszystko działa **jednym kliknięciem**.

---

Oto gotowy **mega skrypt** – możesz go nazwać np. `mega-system-helper.sh`:

```bash
#!/bin/bash

# ===== KOLORY =====
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
CYAN='\033[0;36m'
NC='\033[0m'

SCRIPT="system-helper.sh"

# ===== FUNKCJE =====
type_text() {
    text="$1"
    for ((i=0; i<${#text}; i++)); do
        echo -n "${text:$i:1}"
        sleep 0.02
    done
    echo
}

pause() {
    read -rp "${BLUE}Naciśnij ENTER aby kontynuować...${NC}"
}

spinner() {
    local pid=$!
    local spin='-\|/'
    local i=0
    tput civis
    while kill -0 $pid 2>/dev/null; do
        i=$(( (i+1) %4 ))
        printf "\r${YELLOW}[%c] Pracuję...${NC}" "${spin:$i:1}"
        sleep 0.1
    done
    printf "\r${GREEN}✔ Gotowe!        ${NC}\n"
    tput cnorm
}

header() {
    clear
    echo -e "${CYAN}=====================================${NC}"
    type_text "   Debian Mega System Helper  🚀"
    echo -e "${CYAN}=====================================${NC}"
    echo
}

# ===== SPRAWDZ I INSTALUJ PAKIETY =====
install_packages() {
    packages=("htop" "btop" "neofetch" "sysbench" "stress-ng" "gnome-system-monitor" "dos2unix")
    for pkg in "${packages[@]}"; do
        if ! command -v "$pkg" &>/dev/null; then
            type_text "${YELLOW}Instalowanie brakującego pakietu: $pkg...${NC}"
            sudo apt update && sudo apt install -y "$pkg"
        fi
    done
}

# ===== PRZYGOTUJ PLIK =====
prepare_script() {
    if [ ! -f "$SCRIPT" ]; then
        echo -e "${RED}Plik $SCRIPT nie został znaleziony!${NC}"
        exit 1
    fi
    dos2unix "$SCRIPT"
    chmod +x "$SCRIPT"
}

# ===== MENU SYSTEM HELPER =====
run_helper() {
    ./"$SCRIPT"
}

# ===== BOOT ANIM =====
boot_animation() {
    clear
    type_text "Uruchamianie Mega System Helper..."
    sleep 0.3
    type_text "Ładowanie modułów i narzędzi..."
    sleep 0.3
    type_text "${GREEN}Gotowe!${NC}"
    sleep 0.5
}

# ===== URUCHOMIENIE =====
boot_animation
install_packages
prepare_script
type_text "${GREEN}Wszystko gotowe! Uruchamiam skrypt system helper...${NC}"
sleep 0.5
run_helper
```

---

✅ **Jak to działa:**

1. Skrypt sprawdza i instaluje wszystkie potrzebne pakiety.
2. Naprawia format pliku (`dos2unix`) jeśli był z Windows.
3. Nadaje prawa do wykonywania.
4. Wyświetla fajną animację i odpala Twój oryginalny `system-helper.sh`.

---

Jeżeli chcesz, mogę zrobić **wersję jeszcze bardziej „PRO”**, gdzie:

* Menu główne wyświetla **żywy wykres CPU i RAM** w czasie rzeczywistym,
* Wszystkie testy benchmarków (CPU, RAM, obciążenie) mają **paski postępu**,
* Loguje wszystko do pliku, żeby mieć później podgląd wyników.

Chcesz, żebym od razu zrobił taką super wersję?
Ah, Mikołaj, teraz już rozumiem dokładnie, co się dzieje 😎

Błąd **„nie można uruchomić: nie znaleziono wymaganego pliku”** w Bashu **nie zawsze oznacza, że plik nie istnieje**. Często przy skryptach w Debianie dzieje się tak z **powodu niepoprawnego formatu linii** (Windows CRLF vs Linux LF) albo problemów z kodowaniem.

Skoro Twój plik faktycznie jest w tym samym katalogu, to najprostsza metoda, żeby uruchomić go poprawnie:

---

### 1️⃣ Sprawdź plik:

```bash
ls -l mega-system-helper.sh
file mega-system-helper.sh
```

* `ls -l` pokaże, czy plik jest faktycznie w katalogu.
* `file` pokaże format pliku, np. `ASCII text, with CRLF line terminators` → to problem.

---

### 2️⃣ Napraw format linii (CRLF → LF):

```bash
sudo apt update
sudo apt install -y dos2unix
dos2unix mega-system-helper.sh
```

To konwertuje plik do poprawnego formatu dla Linuksa.

---

### 3️⃣ Nadaj prawa do wykonywania:

```bash
chmod +x mega-system-helper.sh
```

---

### 4️⃣ Uruchom skrypt:

```bash
./mega-system-helper.sh
```

---

💡 **Skrót dla wszystkich kroków naraz:**

```bash
sudo apt update && sudo apt install -y dos2unix && dos2unix mega-system-helper.sh && chmod +x mega-system-helper.sh && ./mega-system-helper.sh
```

Ten jeden wiersz:

* Instaluje `dos2unix` jeśli brak,
* Naprawia format pliku,
* Nadaje prawa do wykonywania,
* Uruchamia skrypt.

---

Jeśli chcesz, mogę zrobić Ci **wersję mega-helpera**, która **już sama naprawia format i instaluje wszystkie pakiety**, tak że wystarczy tylko jedno `./mega-system-helper.sh` i wszystko od razu działa, bez żadnych ręcznych kroków.

Chcesz, żebym zrobił taką w pełni automatyczną wersję?
Jasne, Mikołaj 😎 Zrobimy tak, żeby Twój skrypt **sam naprawiał format pliku**, **instalował brakujące pakiety** i uruchamiał Twój `system-helper.sh` – wszystko w jednym, profesjonalnie i bez problemów z CRLF.

Oto gotowa wersja Twojego skryptu z **automatyczną naprawą i instalacją**:

```bash
#!/bin/bash

# ===== KOLORY =====
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
CYAN='\033[0;36m'
NC='\033[0m'

SCRIPT="system-helper.sh"

# ===== FUNKCJE =====
type_text() {
    text="$1"
    for ((i=0; i<${#text}; i++)); do
        echo -n "${text:$i:1}"
        sleep 0.02
    done
    echo
}

pause() {
    read -rp "${BLUE}Naciśnij ENTER aby kontynuować...${NC}"
}

spinner() {
    local pid=$!
    local spin='-\|/'
    local i=0
    tput civis
    while kill -0 $pid 2>/dev/null; do
        i=$(( (i+1) %4 ))
        printf "\r${YELLOW}[%c] Pracuję...${NC}" "${spin:$i:1}"
        sleep 0.1
    done
    printf "\r${GREEN}✔ Gotowe!        ${NC}\n"
    tput cnorm
}

header() {
    clear
    echo -e "${CYAN}=====================================${NC}"
    type_text "   Debian Mega System Helper  🚀"
    echo -e "${CYAN}=====================================${NC}"
    echo
}

# ===== INSTALACJA PAKIETÓW =====
install_packages() {
    packages=("htop" "btop" "neofetch" "sysbench" "stress-ng" "gnome-system-monitor" "dos2unix")
    for pkg in "${packages[@]}"; do
        if ! command -v "$pkg" &>/dev/null; then
            type_text "${YELLOW}Instalowanie brakującego pakietu: $pkg...${NC}"
            sudo apt update && sudo apt install -y "$pkg"
        fi
    done
}

# ===== NAPRAWA I PRZYGOTOWANIE PLIKU =====
prepare_script() {
    if [ ! -f "$SCRIPT" ]; then
        echo -e "${RED}Plik $SCRIPT nie został znaleziony!${NC}"
        exit 1
    fi
    # napraw format linii
    dos2unix "$SCRIPT"
    # nadaj prawa do wykonywania
    chmod +x "$SCRIPT"
}

# ===== URUCHOMIENIE SYSTEM HELPERA =====
run_helper() {
    ./"$SCRIPT"
}

# ===== ANIMACJA STARTOWA =====
boot_animation() {
    clear
    type_text "Uruchamianie Mega System Helper..."
    sleep 0.3
    type_text "Ładowanie modułów i narzędzi..."
    sleep 0.3
    type_text "${GREEN}Gotowe!${NC}"
    sleep 0.5
}

# ===== START =====
boot_animation
install_packages
prepare_script
type_text "${GREEN}Wszystko gotowe! Uruchamiam skrypt system helper...${NC}"
sleep 0.5
run_helper
```

---

✅ **Co ten skrypt robi automatycznie:**

1. Sprawdza, czy `system-helper.sh` istnieje.
2. Naprawia **format linii** CRLF → LF, jeśli plik był z Windowsa.
3. Nadaje prawa do wykonywania.
4. Sprawdza i instaluje **wszystkie potrzebne narzędzia** (`htop`, `btop`, `neofetch`, `sysbench`, `stress-ng`, `gnome-system-monitor`).
5. Uruchamia Twój oryginalny `system-helper.sh`.

---

Chcesz, żebym zrobił teraz **wersję jeszcze bardziej PRO**, która od razu **pokazuje CPU/RAM w menu i loguje wszystkie wyniki testów do pliku**?
To będzie naprawdę „mega-helper” 🔥
Aha, Mikołaj 😎 Teraz wiemy na 100%, że **problem nie jest w samym skrypcie**, tylko w tym, jak Bash interpretuje plik. Nawet jeśli plik jest w katalogu, komunikat:

```
nie można uruchomić: nie znaleziono wymaganego pliku
```

zwykle oznacza jedno z dwóch:

---

### 1️⃣ Plik ma **Windowsowy format linii (CRLF)**

Linux potrzebuje **LF**, a jeśli skrypt był edytowany w Windowsie, Bash nie rozpozna shebanga `#!/bin/bash`.
Można to naprawić:

```bash
sudo apt update
sudo apt install -y dos2unix
dos2unix system2.0-helper.sh
```

---

### 2️⃣ Brak praw do wykonywania

Nadaj prawa do wykonywania:

```bash
chmod +x system2.0-helper.sh
```

---

### 3️⃣ Uruchom skrypt poprawnie

```bash
./system2.0-helper.sh
```

---

### 🔥 Jeden wiersz – wszystko od razu

```bash
sudo apt update && sudo apt install -y dos2unix && dos2unix system2.0-helper.sh && chmod +x system2.0-helper.sh && ./system2.0-helper.sh
```

---

💡 Jeśli chcesz, mogę Ci teraz zrobić **jedną wersję mega-helpera**, która:

* Sama sprawdza format pliku i naprawia go,
* Instaluje brakujące pakiety,
* Nadaje prawa do wykonywania,
* Od razu uruchamia system-helper,

Tak że wystarczy **jedno `./mega-helper.sh` i działa wszystko**, bez żadnych dodatkowych poleceń.

Chcesz, żebym taką zrobił?
O tak, Mikołaj 😎, jeśli szukasz czegoś **bardziej wypasionego niż `htop`**, to jest kilka naprawdę fajnych alternatyw na Debiana 12, które dają **więcej informacji i lepszą wizualizację**:

---

### 1️⃣ **btop**

* Tak naprawdę jest rozwinięciem `htop` z kolorowymi wykresami.
* Pokazuje **CPU, RAM, dysk, sieć i procesy** w jednym, bardzo ładnym interfejsie.
* Instalacja:

```bash
sudo apt install btop
btop
```

---

### 2️⃣ **glances**

* Bardzo kompleksowe narzędzie „all-in-one”.
* Pokazuje **CPU, RAM, swap, dysk, sieć, procesy, temperaturę**, wszystko w jednym ekranie.
* Instalacja:

```bash
sudo apt install glances
glances
```

---

### 3️⃣ **bashtop** *(starsza wersja btop, ale też fajna)*

* Piękny, kolorowy interfejs, trochę wolniejszy niż btop.
* Jeśli masz btop, to wystarczy – bashtop jest w zasadzie przestarzały.

---

### 4️⃣ **gotop**

* Nowoczesny monitor terminalowy napisany w Go.
* Bardzo eleganckie wykresy i **monitorowanie GPU**.
* Instalacja wymaga snap lub build z repozytorium Go:

```bash
sudo apt install gotop
gotop
```

---

### 5️⃣ **vtop**

* Interaktywny monitor w Node.js.
* Fajny, kolorowy, wygląda jak konsolowa wersja wykresów z systemu.
* Instalacja (Node.js musi być zainstalowany):

```bash
sudo npm install -g vtop
vtop
```

---

💡 **Moja rekomendacja:**

* **`btop`** – najbardziej profesjonalne i nowoczesne dla Debiana, wszystko w terminalu.
* **`glances`** – jeśli chcesz naprawdę pełny przegląd systemu w jednym ekranie.

---

Jeżeli chcesz, mogę zrobić Ci **wersję Twojego system helpera 3.0**, która zamiast `htop` używa **btop lub glances** z automatycznym wykrywaniem i instalacją – czyli **super-profesjonalny monitor systemu w menu** 🚀

Chcesz, żebym taką zrobił?
Okej, Mikołaj 😎, rozumiem – chcesz **bashowy skrypt, który od razu instaluje wszystkie potrzebne narzędzia do monitorowania i testowania systemu**, bez żadnych pytań i ręcznych kroków. Zrobimy wersję “one-click installer”, która:

1. Instaluje:

   * `btop` – nowoczesny monitor systemu
   * `glances` – kompleksowy podgląd systemu
   * `neofetch` – info o systemie
   * `sysbench` – test CPU i RAM
   * `stress-ng` – test obciążeniowy
   * `gnome-system-monitor` – GUI monitor
   * `dos2unix` – do naprawy skryptów jeśli były z Windows

2. Automatycznie naprawia format plików CRLF → LF jeśli potrzeba.

3. Nadaje prawa do wykonywania Twojego helpera.

4. Uruchamia go na końcu.

Oto gotowy skrypt, nazwij go np. `install-all-helper.sh`:

```bash
#!/bin/bash

# ===== KOLORY =====
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
CYAN='\033[0;36m'
NC='\033[0m'

SCRIPT="system-helper.sh"

type_text() {
    text="$1"
    for ((i=0; i<${#text}; i++)); do
        echo -n "${text:$i:1}"
        sleep 0.01
    done
    echo
}

# ===== SPRAWDZENIE I INSTALACJA PAKIETÓW =====
packages=("btop" "glances" "neofetch" "sysbench" "stress-ng" "gnome-system-monitor" "dos2unix")
type_text "${CYAN}Instalacja wszystkich potrzebnych pakietów...${NC}"
for pkg in "${packages[@]}"; do
    if ! command -v "$pkg" &>/dev/null; then
        type_text "${YELLOW}Instalowanie $pkg...${NC}"
        sudo apt update && sudo apt install -y "$pkg"
    else
        type_text "${GREEN}$pkg jest już zainstalowany.${NC}"
    fi
done

# ===== NAPRAWA PLIKU HELPERA =====
if [ -f "$SCRIPT" ]; then
    type_text "${CYAN}Naprawa formatu pliku helpera...${NC}"
    dos2unix "$SCRIPT"
    chmod +x "$SCRIPT"
else
    echo -e "${RED}Nie znaleziono pliku $SCRIPT!${NC}"
    exit 1
fi

# ===== URUCHOMIENIE HELPERA =====
type_text "${GREEN}Wszystko gotowe! Uruchamiam $SCRIPT...${NC}"
./"$SCRIPT"
```

---

💡 **Jak użyć:**

1. Zapisz skrypt np. jako `install-all-helper.sh` w tym samym katalogu co `system-helper.sh`.
2. Nadaj prawa:

```bash
chmod +x install-all-helper.sh
```

3. Uruchom:

```bash
./install-all-helper.sh
```

Skrypt:

* Instaluje wszystko, co potrzebne,
* Naprawia Twój helper,
* Od razu go uruchamia.

---

Jeżeli chcesz, mogę teraz zrobić **wersję mega-pro**, która dodatkowo:

* Wyświetla **żywy wykres CPU/RAM** w menu,
* Loguje wszystkie testy i aktualizacje do pliku,
* Ma animacje i paski postępu,
* I pozwala uruchamiać wszystkie testy jednym kliknięciem.

Chcesz, żebym zrobił tę wersję?
Ah, rozumiem, Mikołaj 😎 – chcesz, żeby w tym szybkim instalatorze **był też htop**, nie tylko btop i glances. Jasne! Możemy go dodać do listy pakietów, żeby był od razu zainstalowany.

Oto poprawiona wersja skryptu:

```bash
#!/bin/bash

# ===== KOLORY =====
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
CYAN='\033[0;36m'
NC='\033[0m'

SCRIPT="system-helper.sh"

type_text() {
    text="$1"
    for ((i=0; i<${#text}; i++)); do
        echo -n "${text:$i:1}"
        sleep 0.01
    done
    echo
}

# ===== SPRAWDZENIE I INSTALACJA PAKIETÓW =====
packages=("htop" "btop" "glances" "neofetch" "sysbench" "stress-ng" "gnome-system-monitor" "dos2unix")
type_text "${CYAN}Instalacja wszystkich potrzebnych pakietów...${NC}"
for pkg in "${packages[@]}"; do
    if ! command -v "$pkg" &>/dev/null; then
        type_text "${YELLOW}Instalowanie $pkg...${NC}"
        sudo apt update && sudo apt install -y "$pkg"
    else
        type_text "${GREEN}$pkg jest już zainstalowany.${NC}"
    fi
done

# ===== NAPRAWA PLIKU HELPERA =====
if [ -f "$SCRIPT" ]; then
    type_text "${CYAN}Naprawa formatu pliku helpera...${NC}"
    dos2unix "$SCRIPT"
    chmod +x "$SCRIPT"
else
    echo -e "${RED}Nie znaleziono pliku $SCRIPT!${NC}"
    exit 1
fi

# ===== URUCHOMIENIE HELPERA =====
type_text "${GREEN}Wszystko gotowe! Uruchamiam $SCRIPT...${NC}"
./"$SCRIPT"
```

---

✅ **Co teraz robi:**

* Instaluje **htop**, btop, glances i wszystkie inne narzędzia.
* Naprawia format pliku helpera (CRLF → LF).
* Nadaje prawa do wykonywania.
* Od razu uruchamia Twój `system-helper.sh`.

---

Jeśli chcesz, mogę teraz zrobić **super-wersję 3.0 PRO**, gdzie w menu wybierasz **htop, btop, glances** i inne testy, a wszystko działa **jak interaktywny dashboard w terminalu** 🚀

Chcesz, żebym od razu zrobił taką mega wersję?
Aha, Mikołaj 😎 – teraz rozumiem: chcesz **interaktywny skrypt**, który po uruchomieniu daje Ci **menu z numerami** i pozwala wybrać, czy np.:

1. Instalować wszystkie potrzebne narzędzia
2. Uruchomić system helper
3. Sprawdzić informacje o systemie
4. Wyjść

To możemy zrobić w **bardzo prosty i czytelny sposób**, z kolorami i spinnerem.

Oto gotowa wersja:

```bash
#!/bin/bash

# ===== KOLORY =====
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
CYAN='\033[0;36m'
NC='\033[0m'

SCRIPT="system-helper.sh"

type_text() {
    text="$1"
    for ((i=0; i<${#text}; i++)); do
        echo -n "${text:$i:1}"
        sleep 0.01
    done
    echo
}

pause() {
    read -rp "${BLUE}Naciśnij ENTER aby kontynuować...${NC}"
}

spinner() {
    local pid=$!
    local spin='-\|/'
    local i=0
    tput civis
    while kill -0 $pid 2>/dev/null; do
        i=$(( (i+1) %4 ))
        printf "\r${YELLOW}[%c] Pracuję...${NC}" "${spin:$i:1}"
        sleep 0.1
    done
    printf "\r${GREEN}✔ Gotowe!        ${NC}\n"
    tput cnorm
}

install_packages() {
    packages=("htop" "btop" "glances" "neofetch" "sysbench" "stress-ng" "gnome-system-monitor" "dos2unix")
    for pkg in "${packages[@]}"; do
        if ! command -v "$pkg" &>/dev/null; then
            type_text "${YELLOW}Instalowanie $pkg...${NC}"
            sudo apt update && sudo apt install -y "$pkg"
        else
            type_text "${GREEN}$pkg jest już zainstalowany.${NC}"
        fi
    done
}

prepare_script() {
    if [ -f "$SCRIPT" ]; then
        dos2unix "$SCRIPT"
        chmod +x "$SCRIPT"
    else
        echo -e "${RED}Nie znaleziono pliku $SCRIPT!${NC}"
        exit 1
    fi
}

run_helper() {
    ./"$SCRIPT"
}

show_system_info() {
    type_text "Informacje o systemie:"
    echo -e "${YELLOW}Host:${NC} $(hostname)"
    echo -e "${YELLOW}Kernel:${NC} $(uname -r)"
    echo -e "${YELLOW}Uptime:${NC} $(uptime -p)"
    echo -e "${YELLOW}CPU:${NC} $(lscpu | grep 'Model name' | sed 's/Model name: *//')"
    echo -e "${YELLOW}RAM:${NC} $(free -h | grep Mem | awk '{print $3 "/" $2}')"
    echo -e "${YELLOW}Dysk:${NC}"
    df -h /
    pause
}

# ===== MENU =====
while true; do
    clear
    echo -e "${CYAN}==============================${NC}"
    type_text "   Debian System Helper  🚀"
    echo -e "${CYAN}==============================${NC}"
    echo
    echo -e "${YELLOW}1)${NC} Instalacja wszystkich pakietów"
    echo -e "${YELLOW}2)${NC} Uruchom system helper"
    echo -e "${YELLOW}3)${NC} Informacje o systemie"
    echo -e "${YELLOW}4)${NC} Wyjście"
    echo
    read -rp "Wybierz opcję: " choice

    case $choice in
        1)
            install_packages
            pause
            ;;
        2)
            prepare_script
            run_helper
            pause
            ;;
        3)
            show_system_info
            ;;
        4)
            type_text "Do zobaczenia 😎"
            exit 0
            ;;
        *)
            type_text "${RED}Nieprawidłowa opcja!${NC}"
            sleep 1
            ;;
    esac
done
```

---

✅ **Jak działa:**

* Menu z numerami 1, 2, 3, 4
* Możesz **instalować pakiety** albo **uruchomić helpera**
* Pokazuje podstawowe informacje o systemie
* Wyjście po numerze 4
* Wszystko kolorowe i z animacjami

---

Jeżeli chcesz, mogę teraz zrobić **wersję ultra-pro**, gdzie w menu dodatkowo:

* Wybierasz **htop, btop, glances** osobno,
* Robisz test CPU i RAM (`sysbench`),
* Uruchamiasz test obciążeniowy (`stress-ng`),
* Wszystko w jednym menu z numerami i paskami postępu.

Chcesz, żebym od razu zrobił taką mega wersję?
Możesz nazwać jak chcesz 😄, ale najlepiej coś **krótkiego, bez spacji** i z końcówką `.sh`.

Kilka fajnych propozycji:

### Proste i czytelne

* `system-helper.sh`
* `debian-helper.sh`
* `sysmenu.sh`
* `system-menu.sh`

### Bardziej “pro”

* `debian-toolkit.sh`
* `system-manager.sh`
* `syscontrol.sh`
* `mega-helper.sh` 😎

### Jak ja bym polecił:

👉 **`system-helper.sh`** – pasuje idealnie do tego, co robi skrypt.

---

### Jak zapisać i uruchomić

1. Zapisz plik, np.:

```bash
nano system-helper.sh
```

2. Wklej kod → `Ctrl+O` → Enter → `Ctrl+X`

3. Nadaj prawa:

```bash
chmod +x system-helper.sh
```

4. Uruchom:

```bash
./system-helper.sh
```

---

Jeśli chcesz, mogę też wymyślić nazwę w stylu **Minecraft / sci‑fi / hacker / AI** 😏
np. `redstone-os.sh`, `ender-core.sh`, `matrix-sys.sh` itd.
Aha, Mikołaj 😎 – skoro dalej masz **„nie można uruchomić: nie znaleziono wymaganego pliku”**, to teraz już wiadomo na 100%, że problem **nie jest w nazwie ani lokalizacji**, tylko w **formacie pliku lub kodowaniu**. Nawet jeśli plik jest w katalogu, Bash go nie odpali, jeśli:

1. **Plik ma Windowsowe końcówki linii (CRLF)**
2. **Shebang (#!/bin/bash) jest niewłaściwy lub niewidoczny dla Basha**

---

### Naprawa krok po kroku

1️⃣ Zainstaluj `dos2unix` (jeśli go nie ma):

```bash
sudo apt update
sudo apt install -y dos2unix
```

2️⃣ Napraw format pliku:

```bash
dos2unix debian-helper.sh
```

3️⃣ Nadaj prawa do wykonywania:

```bash
chmod +x debian-helper.sh
```

4️⃣ Uruchom skrypt:

```bash
./debian-helper.sh
```

---

### 🔥 Jeden wiersz, który robi wszystko:

```bash
sudo apt update && sudo apt install -y dos2unix && dos2unix debian-helper.sh && chmod +x debian-helper.sh && ./debian-helper.sh
```

---

💡 Jeśli chcesz, mogę teraz zrobić **pełną wersję mega-helpera**, która:

* Sam **naprawia CRLF**,
* **Instaluje wszystkie pakiety** (htop, btop, glances, neofetch, sysbench, stress-ng, gnome-system-monitor),
* **Nadaje prawa do wykonywania**,
* I od razu **uruchamia system-helper**,

tak że wystarczy jedno kliknięcie i **działa wszystko** – zero błędów “nie znaleziono wymaganego pliku”.

Chcesz, żebym taką zrobił?

