cleanup

Signed-off-by: abzcoding <abzcoding@gmail.com>

Author: abzcoding

README.md

@@ -10,12 +10,14 @@
 ## Features
 
 - **Parallel downloading** — splits files into chunks and downloads them simultaneously over multiple connections
-- **Live "carrier" TUI** — refined phosphor-cyan / amber telemetry palette, per-part progress with status glyphs (`⬢ ◉ ◯`), animated overall bar, ETA, per-connection speed readouts, plus a rolling **speed-history sparkline** showing recent throughput trend and peak. Driven by [Bubble Tea](https://github.com/charmbracelet/bubbletea), [Bubbles](https://github.com/charmbracelet/bubbles), [Lip Gloss](https://github.com/charmbracelet/lipgloss), and [Harmonica](https://github.com/charmbracelet/harmonica) spring physics
+- **Retro modem-themed TUI** — vintage data-link terminal aesthetic with animated dial-up handshake, blinking status LEDs (PWR/CD/TX/RX/OH/AA), per-channel progress bars, and aggregate signal meter. Animated file assembly and GPG verification phases. All driven by [Bubble Tea](https://github.com/charmbracelet/bubbletea), [Bubbles](https://github.com/charmbracelet/bubbles), [Lip Gloss](https://github.com/charmbracelet/lipgloss), and [Harmonica](https://github.com/charmbracelet/harmonica) spring physics
+- **Auto-resume detection** — automatically detects partial downloads and prompts to resume without requiring `--resume` flag
 - **Real cancellation** — `q` / `Ctrl-C` actually stops the current download (state saved when resumable); `s` in batch mode skips the current item; `Ctrl-C` (or `q` in batch mode) aborts the entire queue. A live "stopping…/skipping…" overlay shows progress while state is drained safely
+- **Visual state feedback** — LED patterns signal every state: handshake (TX/RX blink), downloading (all active), stopping (OH blinks amber), skipping (all blink red), complete (all solid), error (OH solid red)
 - **Beautiful console logging** — colored, structured output via [charmbracelet/log](https://github.com/charmbracelet/log) when running non-interactively
 - **GPG signature verification** — pass `--verify` to automatically fetch the `.sig` file and verify it with GPG; result is shown inline in the TUI completion screen
 - **Smart re-download prompt** — if the target file already exists, a styled [Huh](https://github.com/charmbracelet/huh) confirmation form asks before overwriting
-- **Interrupt & resume** — `q` / `Ctrl-C` at any point persists byte offsets to `~/.hget/<task>/state.json`; resume later with `--resume`
+- **Interrupt & resume** — `q` / `Ctrl-C` at any point persists byte offsets to `~/.hget/<task>/state.json`; resume automatically on next run or explicitly with `--resume`
 - **State reconstruction** — if the state file is missing, reconstructs progress from existing part files
 - **Bandwidth limiting** — cap aggregate download speed with `--rate` (e.g. `5MiB`, `500kB`)
 - **Proxy support** — HTTP and SOCKS5 proxies via `--proxy`
@@ -43,6 +45,10 @@ make install        # builds to ./bin/hget and copies to /usr/local/bin
 # Download a file with 8 parallel connections
 hget -n 8 https://example.com/largefile.iso
 
+# If you interrupt (Ctrl-C), just run the same command again
+# hget will detect the partial download and ask if you want to resume
+hget -n 8 https://example.com/largefile.iso
+
 # Limit bandwidth to 5 MB/s across all connections
 hget -n 4 -rate 5MiB https://example.com/largefile.iso
 
@@ -92,15 +98,17 @@ hget -n 16 -rate 10MiB "https://releases.ubuntu.com/24.04/ubuntu-24.04-live-serv
 
 ## How It Works
 
-1. **Probe** — `HEAD` request (falls back to `GET bytes=0-0`) detects `Accept-Ranges` and `Content-Length`.
-2. **Exists check** — if the destination file is already present, a [Huh](https://github.com/charmbracelet/huh) confirmation form asks whether to overwrite (skipped in non-TTY mode).
-3. **Split** — file is divided into *n* equal byte ranges; each range is stored as `~/.hget/<task>/<task>.part000000` … `.partN`.
-4. **Download** — goroutines download each part concurrently, appending bytes to their part file; a shared `rate.Limiter` enforces the bandwidth cap across all connections.
-5. **Join** — on completion, part files are sorted lexicographically and concatenated into the final file in the working directory.
-6. **Verify** *(optional, `--verify`)* — the `.sig` file is fetched from `<URL>.sig`, written next to the download, and passed to `gpg --verify`. The result (`✓ Valid` / `✗ Invalid`) is shown on the TUI completion screen and the `.sig` file is cleaned up.
-7. **Cleanup** — `~/.hget/<task>/` is removed.
-
-On **Ctrl-C** the current byte offsets are persisted to `~/.hget/<task>/state.json` so the download resumes exactly where it left off.
+1. **Handshake** — animated modem connection sequence shows 4 phases: DIALING → CARRIER DETECT → HANDSHAKE → LINK ESTABLISHED
+2. **Probe** — `HEAD` request (falls back to `GET bytes=0-0`) detects `Accept-Ranges` and `Content-Length`
+3. **Resume check** — if partial download exists, prompts "Resume from where you left off? [Y/n]"
+4. **Exists check** — if the destination file is already present, a [Huh](https://github.com/charmbracelet/huh) confirmation form asks whether to overwrite (skipped in non-TTY mode)
+5. **Split** — file is divided into *n* equal byte ranges; each range is stored as `~/.hget/<task>/<task>.part000000` … `.partN`
+6. **Download** — data-link panel shows per-channel progress with blinking activity LEDs; goroutines download each part concurrently; a shared `rate.Limiter` enforces the bandwidth cap
+7. **Join** — animated assembly visualization shows parts being merged; files are sorted lexicographically and concatenated into the final file
+8. **Verify** *(optional, `--verify`)* — animated key/lock visualization while `.sig` file is fetched and `gpg --verify` runs; result shown on completion screen
+9. **Cleanup** — `~/.hget/<task>/` is removed
+
+On **Ctrl-C** or **q**, the data-link panel shows STOPPING status with blinking OH LED while byte offsets are persisted to `~/.hget/<task>/state.json`. On **s** (skip in batch mode), all LEDs blink red while the download is discarded.
 
 ## Project Structure
 

cmd/hget/main.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"errors"
 	"flag"
+	"fmt"
 	"os"
 	"os/signal"
 	"runtime"
@@ -78,21 +79,27 @@ func main() {
 	downloadURL := args[0]
 	destFile := util.TaskFromURL(downloadURL)
 
+	// Check if final file already exists
 	if _, err := os.Stat(destFile); err == nil {
 		if !ui.ConfirmRedownload(destFile) {
-			ui.Warnf("Skipping download — %s already exists.\n", destFile)
+			ui.ShowMessage(ui.MessageInfo, "DOWNLOAD SKIPPED", fmt.Sprintf("File already exists: %s", destFile))
 			if *verify {
 				ok, detail := downloader.RunVerify(downloadURL, *skiptls, proxy, *timeout)
 				ui.PrintVerifySummary(ok, detail)
 			}
 			return
 		}
+		// User wants to redownload — clean up any partial state
+		if util.ExistDir(state.FolderOf(downloadURL)) {
+			err := os.RemoveAll(state.FolderOf(downloadURL))
+			util.FatalCheck(err)
+		}
 	}
 
-	if util.ExistDir(state.FolderOf(downloadURL)) {
-		ui.Warnf("Downloading task already exists, remove it first\n")
-		err := os.RemoveAll(state.FolderOf(downloadURL))
-		util.FatalCheck(err)
+	// Check for resumable partial download
+	var st *state.State
+	if state.Exists(downloadURL) {
+		st, _ = state.PromptResume(downloadURL)
 	}
 
 	itemCtx, cancelItem := context.WithCancelCause(rootCtx)
@@ -110,7 +117,7 @@ func main() {
 		BatchCurrent: 0,
 		BatchTotal:   0,
 	}, func() error {
-		if err := downloader.Execute(itemCtx, downloadURL, nil, *conn, *skiptls, proxy, bwLimit, *timeout); err != nil {
+		if err := downloader.Execute(itemCtx, downloadURL, st, *conn, *skiptls, proxy, bwLimit, *timeout); err != nil {
 			return err
 		}
 		if *verify {
@@ -137,20 +144,20 @@ func runResume(rootCtx context.Context, resumeTask string, conn int, skiptls boo
 	st, err := state.Resume(resumeTask)
 	if err != nil {
 		if !os.IsNotExist(err) {
-			ui.Errorf("Resume failed: %v\n", err)
+			ui.ShowMessage(ui.MessageError, "RESUME FAILED", fmt.Sprintf("Could not load saved state: %v", err))
 			os.Exit(1)
 		}
 		// No state.json — try to reconstruct from existing part files.
 		st, err = downloader.ReconstructStateFromParts(resumeTask, skiptls, proxy, timeout)
 		if err == nil {
-			ui.Printf("Reconstructed state from %d part files — resuming.\n", len(st.Parts))
+			ui.ShowMessage(ui.MessageInfo, "STATE RECONSTRUCTED", fmt.Sprintf("Recovered %d part files — resuming download", len(st.Parts)))
 			runOne(rootCtx, st.URL, st, conn, skiptls, proxy, bwLimit, timeout)
 			return
 		}
 		// No part files either — start fresh if it looks like a URL.
-		ui.Warnf("No saved state found for %q — starting fresh download.\n", resumeTask)
+		ui.ShowMessage(ui.MessageWarning, "NO SAVED STATE", fmt.Sprintf("Starting fresh download for: %s", resumeTask))
 		if !util.IsURL(resumeTask) {
-			ui.Errorf("No saved state found for task %q and it is not a URL.\n", resumeTask)
+			ui.ShowMessage(ui.MessageError, "INVALID TASK", fmt.Sprintf("No saved state found and not a valid URL: %s", resumeTask))
 			os.Exit(1)
 		}
 		runOne(rootCtx, resumeTask, nil, conn, skiptls, proxy, bwLimit, timeout)

internal/batch/batch.go

@@ -27,7 +27,7 @@ func RunBatchDownloads(ctx context.Context, filePath string, conn int, skiptls b
 	// ── Read and validate URL list ────────────────────────────────────────────
 	f, err := os.Open(filePath)
 	if err != nil {
-		ui.Errorf("could not open URL list %s: %v\n", filePath, err)
+		ui.ShowMessage(ui.MessageError, "FILE ERROR", fmt.Sprintf("Could not open URL list: %s\n%v", filePath, err))
 		return
 	}
 	defer f.Close()
@@ -42,12 +42,12 @@ func RunBatchDownloads(ctx context.Context, filePath string, conn int, skiptls b
 		urls = append(urls, line)
 	}
 	if scanErr := scanner.Err(); scanErr != nil {
-		ui.Errorf("error reading %s: %v\n", filePath, scanErr)
+		ui.ShowMessage(ui.MessageError, "READ ERROR", fmt.Sprintf("Error reading file: %s\n%v", filePath, scanErr))
 		return
 	}
 
 	if len(urls) == 0 {
-		ui.Warnf("No URLs found in %s\n", filePath)
+		ui.ShowMessage(ui.MessageWarning, "EMPTY FILE", fmt.Sprintf("No URLs found in: %s", filePath))
 		return
 	}
 
@@ -252,7 +252,7 @@ func RunBatchDownloads(ctx context.Context, filePath string, conn int, skiptls b
 		// File-exists check (isatty gate is inside ui.ConfirmRedownload).
 		if _, statErr := os.Stat(it.file); statErr == nil {
 			if !ui.ConfirmRedownload(it.file) {
-				ui.Warnf("Skipping — %s already exists.\n", it.file)
+				ui.ShowMessage(ui.MessageInfo, "FILE EXISTS", fmt.Sprintf("Skipping: %s", it.file))
 				it.status = statusSkipped
 				it.reason = "already exists"
 				if verify {
@@ -266,13 +266,18 @@ func RunBatchDownloads(ctx context.Context, filePath string, conn int, skiptls b
 				fmt.Println()
 				continue
 			}
+			// User wants to redownload — clean up any partial state
+			if util.ExistDir(state.FolderOf(it.url)) {
+				if rmErr := os.RemoveAll(state.FolderOf(it.url)); rmErr != nil {
+					ui.Warnf("Could not remove old state: %v\n", rmErr)
+				}
+			}
 		}
 
-		// Remove stale temp dir.
-		if util.ExistDir(state.FolderOf(it.url)) {
-			if rmErr := os.RemoveAll(state.FolderOf(it.url)); rmErr != nil {
-				ui.Warnf("Could not remove old temp dir: %v\n", rmErr)
-			}
+		// Check for resumable partial download
+		var st *state.State
+		if state.Exists(it.url) {
+			st, _ = state.PromptResume(it.url)
 		}
 
 		// Per-item context derived from the batch context, with cancel
@@ -299,7 +304,7 @@ func RunBatchDownloads(ctx context.Context, filePath string, conn int, skiptls b
 			BatchCurrent: i + 1,
 			BatchTotal:   len(items),
 		}, func() error {
-			if err := downloader.Execute(itemCtx, it.url, nil, conn, skiptls, proxy, bwLimit, timeout); err != nil {
+			if err := downloader.Execute(itemCtx, it.url, st, conn, skiptls, proxy, bwLimit, timeout); err != nil {
 				return err
 			}
 			if verify {

internal/state/resume.go

@@ -11,6 +11,60 @@ import (
 	"github.com/abzcoding/hget/internal/util"
 )
 
+// Exists checks if saved state exists for the given URL or task name.
+func Exists(urlOrTask string) bool {
+	_, err := Read(urlOrTask)
+	return err == nil
+}
+
+// PromptResume checks if resumable state exists and asks the user whether to
+// resume or start fresh. Returns the state if resuming, nil if starting fresh.
+func PromptResume(urlOrTask string) (*State, bool) {
+	if !Exists(urlOrTask) {
+		return nil, true // no state, proceed with fresh download
+	}
+
+	// Load state to get download progress
+	st, err := Read(urlOrTask)
+	if err != nil {
+		return nil, true
+	}
+	
+	// Calculate total downloaded bytes
+	var downloaded int64
+	var total int64
+	for _, part := range st.Parts {
+		downloaded += part.RangeFrom
+		total += (part.RangeTo - part.RangeFrom + 1)
+	}
+	
+	// Show animated TUI prompt
+	resume, err := ui.ResumePrompt(util.TaskFromURL(urlOrTask), downloaded, total)
+	if err != nil {
+		// On error, default to fresh download
+		return nil, true
+	}
+	
+	if resume {
+		// Validate part files
+		st, err := Resume(urlOrTask)
+		if err != nil {
+			// If resume fails, start fresh
+			folder := FolderOf(urlOrTask)
+			_ = os.RemoveAll(folder)
+			return nil, true
+		}
+		return st, true
+	}
+	
+	// User chose not to resume — clean up old state
+	folder := FolderOf(urlOrTask)
+	if err := os.RemoveAll(folder); err != nil {
+		// Silently ignore cleanup errors
+	}
+	return nil, true
+}
+
 // TaskPrint reads and prints data about current download jobs.
 func TaskPrint() error {
 	usr, err := user.Current()

internal/ui/datalink.go

@@ -15,6 +15,8 @@ package ui
 // one canonical home.
 
 import (
+	cryptorand "crypto/rand"
+	"encoding/binary"
 	"fmt"
 	"math"
 	"math/rand"
@@ -72,12 +74,21 @@ type dataLink struct {
 }
 
 func newDataLink() dataLink {
+	// Use crypto/rand for seed to satisfy gosec
+	var seed int64
+	var b [8]byte
+	if _, err := cryptorand.Read(b[:]); err == nil {
+		seed = int64(binary.LittleEndian.Uint64(b[:]))
+	} else {
+		seed = time.Now().UnixNano()
+	}
+	
 	return dataLink{
 		pwr: led{brightness: 1},
 		cd:  led{brightness: 1},
 		oh:  led{brightness: 1},
 		aa:  led{brightness: 0.7},
-		rng: rand.New(rand.NewSource(time.Now().UnixNano())),
+		rng: rand.New(rand.NewSource(seed)),
 	}
 }
 
@@ -196,10 +207,18 @@ func (d *dataLink) View(
 		// All LEDs solid on completion
 		txOn, rxOn, aaOn = true, true, true
 	case "STOPPING", "SKIPPING":
-		statusColor = colorAmber
+		if status == "SKIPPING" {
+			statusColor = colorMagenta // Red for skip
+		} else {
+			statusColor = colorAmber // Amber for stop
+		}
 		pwrOn, cdOn = true, true
-		// OH (overload/halt) blinks
+		// OH blinks, TX/RX blink red for SKIPPING
 		ohOn = d.ticks%3 < 2
+		if status == "SKIPPING" {
+			txOn = d.ticks%4 < 2
+			rxOn = d.ticks%4 >= 2
+		}
 	case "ERROR":
 		statusColor = colorMagenta
 		pwrOn = true
@@ -305,7 +324,7 @@ func (d *dataLink) View(
 	// ── channel rows ─────────────────────────────────────────────────────
 	channelLines := make([]string, 0, len(channels))
 	for i, ch := range channels {
-		line := d.renderChannelRow(ch, i)
+		line := d.renderChannelRow(ch, i, status)
 		channelLines = append(channelLines, line)
 	}
 
@@ -331,7 +350,7 @@ func (d *dataLink) View(
 // renderChannelRow renders a single per-connection line:
 //
 //   ▸ CH·01  ┃▰▰▰▰▰▰▰▰▰▰▰▱▱▱▱▱▱▱▱▱▱▱┃   72.3%    ↓ 1.2 MB/s   ●●
-func (d *dataLink) renderChannelRow(ch channelRow, idx int) string {
+func (d *dataLink) renderChannelRow(ch channelRow, idx int, status string) string {
 	bullet := lipgloss.NewStyle().Foreground(colorAmber).Render("▸")
 	label := lipgloss.NewStyle().Foreground(colorSteel).Render(fmt.Sprintf("CH·%02d", ch.Index+1))
 
@@ -363,9 +382,16 @@ func (d *dataLink) renderChannelRow(ch channelRow, idx int) string {
 
 	// Per-channel activity LEDs (2 dots).
 	var act string
+	ledColor := colorPhosphor
+	if status == "SKIPPING" {
+		ledColor = colorMagenta // Red LEDs when skipping
+	} else if status == "ERROR" {
+		ledColor = colorMagenta
+	}
+	
 	if idx < len(d.chanLEDs) {
-		act = d.chanLEDs[idx][0].render(colorPhosphor, colorSlate) +
-			d.chanLEDs[idx][1].render(colorPhosphor, colorSlate)
+		act = d.chanLEDs[idx][0].render(ledColor, colorSlate) +
+			d.chanLEDs[idx][1].render(ledColor, colorSlate)
 	} else {
 		act = lipgloss.NewStyle().Foreground(colorSlate).Render("●●")
 	}