fix: use proper go version in module file (#12)

- Switch to nixos-25.11 for modern apple-sdk packages
- Use apple-sdk_15 which includes SecTrustCopyCertificateChain (macOS 12+)
- Required for Go 1.25 crypto/x509 compatibility on darwin

.github/workflows/ci.yaml

@@ -32,7 +32,28 @@ jobs:
           go-version: "1.25.0"
 
       - name: lint
-        uses: golangci/golangci-lint-action@v6
+        uses: golangci/golangci-lint-action@v8
         with:
-          version: latest
+          version: v2.5.0
+
+  nix-build:
+    strategy:
+      matrix:
+        os: [ubuntu-latest, macos-14]
+    runs-on: ${{ matrix.os }}
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: DeterminateSystems/nix-installer-action@v17
+
+      - uses: nix-community/cache-nix-action@v6
+        with:
+          primary-key: nix-${{ runner.os }}-${{ hashFiles('flake.lock') }}
+          restore-prefixes-first-match: nix-${{ runner.os }}-
+
+      - name: nix flake check
+        run: nix flake check
+
+      - name: nix build
+        run: nix build
 

README.md

@@ -38,6 +38,20 @@ yay -S snitch-bin
 paru -S snitch-bin
 ```
 
+### shell script
+
+```bash
+curl -sSL https://raw.githubusercontent.com/karol-broda/snitch/master/install.sh | sh
+```
+
+installs to `~/.local/bin` if available, otherwise `/usr/local/bin`. override with:
+
+```bash
+curl -sSL https://raw.githubusercontent.com/karol-broda/snitch/master/install.sh | INSTALL_DIR=~/bin sh
+```
+
+> **macos:** the install script automatically removes the quarantine attribute (`com.apple.quarantine`) from the binary to allow it to run without gatekeeper warnings. to disable this, set `KEEP_QUARANTINE=1`.
+
 ### binary
 
 download from [releases](https://github.com/karol-broda/snitch/releases):
@@ -51,6 +65,7 @@ sudo mv snitch /usr/local/bin/
 ```
 
 > **macos:** if blocked with "cannot be opened because the developer cannot be verified", run:
+>
 > ```bash
 > xattr -d com.apple.quarantine /usr/local/bin/snitch
 > ```
@@ -131,6 +146,16 @@ snitch watch -i 1s | jq '.count'
 snitch watch -l -i 500ms
 ```
 
+### `snitch upgrade`
+
+check for updates and upgrade in-place.
+
+```bash
+snitch upgrade              # check for updates
+snitch upgrade --yes        # upgrade automatically
+snitch upgrade -v 0.1.7     # install specific version
+```
+
 ## filters
 
 shortcut flags work on all commands:
@@ -142,9 +167,20 @@ shortcut flags work on all commands:
 -e, --established   established connections
 -4, --ipv4          ipv4 only
 -6, --ipv6          ipv6 only
--n, --numeric       no dns resolution
 ```
 
+## resolution
+
+dns and service name resolution options:
+
+```
+--resolve-addrs     resolve ip addresses to hostnames (default: true)
+--resolve-ports     resolve port numbers to service names
+--no-cache          disable dns caching (force fresh lookups)
+```
+
+dns lookups are performed in parallel and cached for performance. use `--no-cache` to bypass the cache for debugging or when addresses change frequently.
+
 for more specific filtering, use `key=value` syntax with `ls`:
 
 ```bash
@@ -183,8 +219,19 @@ optional config file at `~/.config/snitch/snitch.toml`:
 
 ```toml
 [defaults]
-numeric = false
-theme = "auto"
+numeric = false      # disable name resolution
+dns_cache = true     # cache dns lookups (set to false to disable)
+theme = "auto"       # color theme: auto, dark, light, mono
+```
+
+### environment variables
+
+```bash
+SNITCH_THEME=dark          # set default theme
+SNITCH_RESOLVE=0           # disable dns resolution
+SNITCH_DNS_CACHE=0         # disable dns caching
+SNITCH_NO_COLOR=1          # disable color output
+SNITCH_CONFIG=/path/to     # custom config file path
 ```
 
 ## requirements

cmd/cli_test.go

@@ -6,7 +6,8 @@ import (
 	"strings"
 	"testing"
 
-	"snitch/internal/testutil"
+	"github.com/karol-broda/snitch/internal/errutil"
+	"github.com/karol-broda/snitch/internal/testutil"
 )
 
 // TestCLIContract tests the CLI interface contracts as specified in the README
@@ -71,7 +72,7 @@ func TestCLIContract(t *testing.T) {
 			name:           "version",
 			args:           []string{"version"},
 			expectExitCode: 0,
-			expectStdout:   []string{"snitch", "commit:", "built:"},
+			expectStdout:   []string{"snitch", "commit", "built"},
 			expectStderr:   nil,
 			description:    "version command should show version information",
 		},
@@ -364,7 +365,8 @@ func resetGlobalFlags() {
 	filterIPv4 = false
 	filterIPv6 = false
 	colorMode = "auto"
-	numeric = false
+	resolveAddrs = true
+	resolvePorts = false
 }
 
 // TestEnvironmentVariables tests that environment variables are properly handled
@@ -406,16 +408,16 @@ func TestEnvironmentVariables(t *testing.T) {
 		oldEnvVars := make(map[string]string)
 		for key, value := range tt.envVars {
 			oldEnvVars[key] = os.Getenv(key)
-			os.Setenv(key, value)
+			errutil.Setenv(key, value)
 		}
 
 		// Clean up environment variables
 		defer func() {
 			for key, oldValue := range oldEnvVars {
 				if oldValue == "" {
-					os.Unsetenv(key)
+					errutil.Unsetenv(key)
 				} else {
-					os.Setenv(key, oldValue)
+					errutil.Setenv(key, oldValue)
 				}
 			}
 		}()

cmd/golden_test.go

@@ -9,8 +9,8 @@ import (
 	"strings"
 	"testing"
 
-	"snitch/internal/collector"
-	"snitch/internal/testutil"
+	"github.com/karol-broda/snitch/internal/collector"
+	"github.com/karol-broda/snitch/internal/testutil"
 )
 
 var updateGolden = flag.Bool("update-golden", false, "Update golden files")

cmd/json.go

@@ -15,4 +15,5 @@ var jsonCmd = &cobra.Command{
 
 func init() {
 	rootCmd.AddCommand(jsonCmd)
+	addFilterFlags(jsonCmd)
 }

cmd/ls.go

@@ -8,16 +8,18 @@ import (
 	"log"
 	"os"
 	"os/exec"
-	"snitch/internal/collector"
-	"snitch/internal/color"
-	"snitch/internal/config"
-	"snitch/internal/resolver"
 	"strconv"
 	"strings"
 	"text/tabwriter"
 
 	"github.com/charmbracelet/lipgloss"
 	"github.com/spf13/cobra"
+
+	"github.com/karol-broda/snitch/internal/collector"
+	"github.com/karol-broda/snitch/internal/color"
+	"github.com/karol-broda/snitch/internal/config"
+	"github.com/karol-broda/snitch/internal/errutil"
+	"github.com/karol-broda/snitch/internal/resolver"
 	"github.com/tidwall/pretty"
 	"golang.org/x/term"
 )
@@ -30,7 +32,6 @@ var (
 	sortBy        string
 	fields        string
 	colorMode     string
-	numeric       bool
 	plainOutput   bool
 )
 
@@ -51,7 +52,7 @@ Available filters:
 }
 
 func runListCommand(outputFormat string, args []string) {
-	rt, err := NewRuntime(args, colorMode, numeric)
+	rt, err := NewRuntime(args, colorMode)
 	if err != nil {
 		log.Fatal(err)
 	}
@@ -98,14 +99,18 @@ func getFieldMap(c collector.Connection) map[string]string {
 	lport := strconv.Itoa(c.Lport)
 	rport := strconv.Itoa(c.Rport)
 	
-	// Apply name resolution if not in numeric mode
-	if !numeric {
+	// apply address resolution
+	if resolveAddrs {
 		if resolvedLaddr := resolver.ResolveAddr(c.Laddr); resolvedLaddr != c.Laddr {
 			laddr = resolvedLaddr
 		}
 		if resolvedRaddr := resolver.ResolveAddr(c.Raddr); resolvedRaddr != c.Raddr && c.Raddr != "*" && c.Raddr != "" {
 			raddr = resolvedRaddr
 		}
+	}
+
+	// apply port resolution
+	if resolvePorts {
 		if resolvedLport := resolver.ResolvePort(c.Lport, c.Proto); resolvedLport != strconv.Itoa(c.Lport) {
 			lport = resolvedLport
 		}
@@ -182,7 +187,7 @@ func printCSV(conns []collector.Connection, headers bool, timestamp bool, select
 
 func printPlainTable(conns []collector.Connection, headers bool, timestamp bool, selectedFields []string) {
 	w := tabwriter.NewWriter(os.Stdout, 0, 0, 3, ' ', 0)
-	defer w.Flush()
+	defer errutil.Flush(w)
 
 	if len(selectedFields) == 0 {
 		selectedFields = []string{"pid", "process", "user", "proto", "state", "laddr", "lport", "raddr", "rport"}
@@ -196,7 +201,7 @@ func printPlainTable(conns []collector.Connection, headers bool, timestamp bool,
 		for _, field := range selectedFields {
 			headerRow = append(headerRow, strings.ToUpper(field))
 		}
-		fmt.Fprintln(w, strings.Join(headerRow, "\t"))
+		errutil.Ignore(fmt.Fprintln(w, strings.Join(headerRow, "\t")))
 	}
 
 	for _, conn := range conns {
@@ -205,7 +210,7 @@ func printPlainTable(conns []collector.Connection, headers bool, timestamp bool,
 		for _, field := range selectedFields {
 			row = append(row, fieldMap[field])
 		}
-		fmt.Fprintln(w, strings.Join(row, "\t"))
+		errutil.Ignore(fmt.Fprintln(w, strings.Join(row, "\t")))
 	}
 }
 
@@ -395,9 +400,9 @@ func init() {
 	lsCmd.Flags().StringVarP(&sortBy, "sort", "s", cfg.Defaults.SortBy, "Sort by column (e.g., pid:desc)")
 	lsCmd.Flags().StringVarP(&fields, "fields", "f", strings.Join(cfg.Defaults.Fields, ","), "Comma-separated list of fields to show")
 	lsCmd.Flags().StringVar(&colorMode, "color", cfg.Defaults.Color, "Color mode (auto, always, never)")
-	lsCmd.Flags().BoolVarP(&numeric, "numeric", "n", cfg.Defaults.Numeric, "Don't resolve hostnames")
 	lsCmd.Flags().BoolVarP(&plainOutput, "plain", "p", false, "Plain output (parsable, no styling)")
 
-	// shared filter flags
+	// shared flags
 	addFilterFlags(lsCmd)
+	addResolutionFlags(lsCmd)
 }

cmd/ls_test.go

@@ -4,8 +4,8 @@ import (
 	"strings"
 	"testing"
 
-	"snitch/internal/collector"
-	"snitch/internal/testutil"
+	"github.com/karol-broda/snitch/internal/collector"
+	"github.com/karol-broda/snitch/internal/testutil"
 )
 
 func TestLsCommand_EmptyResults(t *testing.T) {

cmd/root.go

@@ -3,11 +3,12 @@ package cmd
 import (
 	"fmt"
 	"os"
-	"snitch/internal/config"
 
+	"github.com/karol-broda/snitch/internal/config"
 	"github.com/spf13/cobra"
 )
 
+
 var (
 	cfgFile string
 )
@@ -42,9 +43,10 @@ func init() {
 
 	// add top's flags to root so `snitch -l` works (defaults to top command)
 	cfg := config.Get()
-	rootCmd.Flags().StringVar(&topTheme, "theme", cfg.Defaults.Theme, "Theme for TUI (dark, light, mono, auto)")
+	rootCmd.Flags().StringVar(&topTheme, "theme", cfg.Defaults.Theme, "Theme for TUI (see 'snitch themes')")
 	rootCmd.Flags().DurationVarP(&topInterval, "interval", "i", 0, "Refresh interval (default 1s)")
 
-	// shared filter flags for root command
+	// shared flags for root command
 	addFilterFlags(rootCmd)
+	addResolutionFlags(rootCmd)
 }

cmd/runtime.go

@@ -2,8 +2,10 @@ package cmd
 
 import (
 	"fmt"
-	"snitch/internal/collector"
-	"snitch/internal/color"
+	"github.com/karol-broda/snitch/internal/collector"
+	"github.com/karol-broda/snitch/internal/color"
+	"github.com/karol-broda/snitch/internal/config"
+	"github.com/karol-broda/snitch/internal/resolver"
 	"strconv"
 	"strings"
 
@@ -11,7 +13,7 @@ import (
 )
 
 // Runtime holds the shared state for all commands.
-// it handles common filter logic, fetching, and filtering connections.
+// it handles common filter logic, fetching, filtering, and resolution.
 type Runtime struct {
 	// filter options built from flags and args
 	Filters collector.FilterOptions
@@ -21,7 +23,9 @@ type Runtime struct {
 
 	// common settings
 	ColorMode    string
-	Numeric   bool
+	ResolveAddrs bool
+	ResolvePorts bool
+	NoCache      bool
 }
 
 // shared filter flags - used by all commands
@@ -34,6 +38,13 @@ var (
 	filterIPv6   bool
 )
 
+// shared resolution flags - used by all commands
+var (
+	resolveAddrs bool
+	resolvePorts bool
+	noCache      bool
+)
+
 // BuildFilters constructs FilterOptions from command args and shortcut flags.
 func BuildFilters(args []string) (collector.FilterOptions, error) {
 	filters, err := ParseFilterArgs(args)
@@ -73,9 +84,15 @@ func FetchConnections(filters collector.FilterOptions) ([]collector.Connection,
 }
 
 // NewRuntime creates a runtime with fetched and filtered connections.
-func NewRuntime(args []string, colorMode string, numeric bool) (*Runtime, error) {
+func NewRuntime(args []string, colorMode string) (*Runtime, error) {
 	color.Init(colorMode)
 
+	cfg := config.Get()
+	
+	// configure resolver with cache setting (flag overrides config)
+	effectiveNoCache := noCache || !cfg.Defaults.DNSCache
+	resolver.SetNoCache(effectiveNoCache)
+
 	filters, err := BuildFilters(args)
 	if err != nil {
 		return nil, fmt.Errorf("failed to parse filters: %w", err)
@@ -86,12 +103,30 @@ func NewRuntime(args []string, colorMode string, numeric bool) (*Runtime, error)
 		return nil, fmt.Errorf("failed to fetch connections: %w", err)
 	}
 
-	return &Runtime{
+	rt := &Runtime{
 		Filters:      filters,
 		Connections:  connections,
 		ColorMode:    colorMode,
-		Numeric:     numeric,
-	}, nil
+		ResolveAddrs: resolveAddrs,
+		ResolvePorts: resolvePorts,
+		NoCache:      effectiveNoCache,
+	}
+
+	// pre-warm dns cache by resolving all addresses in parallel
+	if resolveAddrs {
+		rt.PreWarmDNS()
+	}
+
+	return rt, nil
+}
+
+// PreWarmDNS resolves all connection addresses in parallel to warm the cache.
+func (r *Runtime) PreWarmDNS() {
+	addrs := make([]string, 0, len(r.Connections)*2)
+	for _, c := range r.Connections {
+		addrs = append(addrs, c.Laddr, c.Raddr)
+	}
+	resolver.ResolveAddrsParallel(addrs)
 }
 
 // SortConnections sorts the runtime's connections in place.
@@ -199,3 +234,11 @@ func addFilterFlags(cmd *cobra.Command) {
 	cmd.Flags().BoolVarP(&filterIPv6, "ipv6", "6", false, "Only show IPv6 connections")
 }
 
+// addResolutionFlags adds the common resolution flags to a command.
+func addResolutionFlags(cmd *cobra.Command) {
+	cfg := config.Get()
+	cmd.Flags().BoolVar(&resolveAddrs, "resolve-addrs", !cfg.Defaults.Numeric, "Resolve IP addresses to hostnames")
+	cmd.Flags().BoolVar(&resolvePorts, "resolve-ports", false, "Resolve port numbers to service names")
+	cmd.Flags().BoolVar(&noCache, "no-cache", !cfg.Defaults.DNSCache, "Disable DNS caching (force fresh lookups)")
+}
+

cmd/runtime_test.go

@@ -0,0 +1,525 @@
+package cmd
+
+import (
+	"testing"
+
+	"github.com/karol-broda/snitch/internal/collector"
+)
+
+func TestParseFilterArgs_Empty(t *testing.T) {
+	filters, err := ParseFilterArgs([]string{})
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if filters.Proto != "" {
+		t.Errorf("expected empty proto, got %q", filters.Proto)
+	}
+}
+
+func TestParseFilterArgs_Proto(t *testing.T) {
+	filters, err := ParseFilterArgs([]string{"proto=tcp"})
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if filters.Proto != "tcp" {
+		t.Errorf("expected proto 'tcp', got %q", filters.Proto)
+	}
+}
+
+func TestParseFilterArgs_State(t *testing.T) {
+	filters, err := ParseFilterArgs([]string{"state=LISTEN"})
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if filters.State != "LISTEN" {
+		t.Errorf("expected state 'LISTEN', got %q", filters.State)
+	}
+}
+
+func TestParseFilterArgs_PID(t *testing.T) {
+	filters, err := ParseFilterArgs([]string{"pid=1234"})
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if filters.Pid != 1234 {
+		t.Errorf("expected pid 1234, got %d", filters.Pid)
+	}
+}
+
+func TestParseFilterArgs_InvalidPID(t *testing.T) {
+	_, err := ParseFilterArgs([]string{"pid=notanumber"})
+	if err == nil {
+		t.Error("expected error for invalid pid")
+	}
+}
+
+func TestParseFilterArgs_Proc(t *testing.T) {
+	filters, err := ParseFilterArgs([]string{"proc=nginx"})
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if filters.Proc != "nginx" {
+		t.Errorf("expected proc 'nginx', got %q", filters.Proc)
+	}
+}
+
+func TestParseFilterArgs_Lport(t *testing.T) {
+	filters, err := ParseFilterArgs([]string{"lport=80"})
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if filters.Lport != 80 {
+		t.Errorf("expected lport 80, got %d", filters.Lport)
+	}
+}
+
+func TestParseFilterArgs_InvalidLport(t *testing.T) {
+	_, err := ParseFilterArgs([]string{"lport=notaport"})
+	if err == nil {
+		t.Error("expected error for invalid lport")
+	}
+}
+
+func TestParseFilterArgs_Rport(t *testing.T) {
+	filters, err := ParseFilterArgs([]string{"rport=443"})
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if filters.Rport != 443 {
+		t.Errorf("expected rport 443, got %d", filters.Rport)
+	}
+}
+
+func TestParseFilterArgs_InvalidRport(t *testing.T) {
+	_, err := ParseFilterArgs([]string{"rport=invalid"})
+	if err == nil {
+		t.Error("expected error for invalid rport")
+	}
+}
+
+func TestParseFilterArgs_UserByName(t *testing.T) {
+	filters, err := ParseFilterArgs([]string{"user=root"})
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if filters.User != "root" {
+		t.Errorf("expected user 'root', got %q", filters.User)
+	}
+}
+
+func TestParseFilterArgs_UserByUID(t *testing.T) {
+	filters, err := ParseFilterArgs([]string{"user=1000"})
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if filters.UID != 1000 {
+		t.Errorf("expected uid 1000, got %d", filters.UID)
+	}
+}
+
+func TestParseFilterArgs_Laddr(t *testing.T) {
+	filters, err := ParseFilterArgs([]string{"laddr=127.0.0.1"})
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if filters.Laddr != "127.0.0.1" {
+		t.Errorf("expected laddr '127.0.0.1', got %q", filters.Laddr)
+	}
+}
+
+func TestParseFilterArgs_Raddr(t *testing.T) {
+	filters, err := ParseFilterArgs([]string{"raddr=8.8.8.8"})
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if filters.Raddr != "8.8.8.8" {
+		t.Errorf("expected raddr '8.8.8.8', got %q", filters.Raddr)
+	}
+}
+
+func TestParseFilterArgs_Contains(t *testing.T) {
+	filters, err := ParseFilterArgs([]string{"contains=google"})
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if filters.Contains != "google" {
+		t.Errorf("expected contains 'google', got %q", filters.Contains)
+	}
+}
+
+func TestParseFilterArgs_Interface(t *testing.T) {
+	filters, err := ParseFilterArgs([]string{"if=eth0"})
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if filters.Interface != "eth0" {
+		t.Errorf("expected interface 'eth0', got %q", filters.Interface)
+	}
+
+	// test alternative syntax
+	filters2, err := ParseFilterArgs([]string{"interface=lo"})
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if filters2.Interface != "lo" {
+		t.Errorf("expected interface 'lo', got %q", filters2.Interface)
+	}
+}
+
+func TestParseFilterArgs_Mark(t *testing.T) {
+	filters, err := ParseFilterArgs([]string{"mark=0x1234"})
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if filters.Mark != "0x1234" {
+		t.Errorf("expected mark '0x1234', got %q", filters.Mark)
+	}
+}
+
+func TestParseFilterArgs_Namespace(t *testing.T) {
+	filters, err := ParseFilterArgs([]string{"namespace=default"})
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if filters.Namespace != "default" {
+		t.Errorf("expected namespace 'default', got %q", filters.Namespace)
+	}
+}
+
+func TestParseFilterArgs_Inode(t *testing.T) {
+	filters, err := ParseFilterArgs([]string{"inode=123456"})
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if filters.Inode != 123456 {
+		t.Errorf("expected inode 123456, got %d", filters.Inode)
+	}
+}
+
+func TestParseFilterArgs_InvalidInode(t *testing.T) {
+	_, err := ParseFilterArgs([]string{"inode=notanumber"})
+	if err == nil {
+		t.Error("expected error for invalid inode")
+	}
+}
+
+func TestParseFilterArgs_Multiple(t *testing.T) {
+	filters, err := ParseFilterArgs([]string{"proto=tcp", "state=LISTEN", "lport=80"})
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if filters.Proto != "tcp" {
+		t.Errorf("expected proto 'tcp', got %q", filters.Proto)
+	}
+	if filters.State != "LISTEN" {
+		t.Errorf("expected state 'LISTEN', got %q", filters.State)
+	}
+	if filters.Lport != 80 {
+		t.Errorf("expected lport 80, got %d", filters.Lport)
+	}
+}
+
+func TestParseFilterArgs_InvalidFormat(t *testing.T) {
+	_, err := ParseFilterArgs([]string{"invalidformat"})
+	if err == nil {
+		t.Error("expected error for invalid format")
+	}
+}
+
+func TestParseFilterArgs_UnknownKey(t *testing.T) {
+	_, err := ParseFilterArgs([]string{"unknownkey=value"})
+	if err == nil {
+		t.Error("expected error for unknown key")
+	}
+}
+
+func TestParseFilterArgs_CaseInsensitiveKeys(t *testing.T) {
+	filters, err := ParseFilterArgs([]string{"PROTO=tcp", "State=LISTEN"})
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if filters.Proto != "tcp" {
+		t.Errorf("expected proto 'tcp', got %q", filters.Proto)
+	}
+	if filters.State != "LISTEN" {
+		t.Errorf("expected state 'LISTEN', got %q", filters.State)
+	}
+}
+
+func TestBuildFilters_TCPOnly(t *testing.T) {
+	// save and restore global flags
+	oldTCP, oldUDP := filterTCP, filterUDP
+	defer func() {
+		filterTCP, filterUDP = oldTCP, oldUDP
+	}()
+
+	filterTCP = true
+	filterUDP = false
+
+	filters, err := BuildFilters([]string{})
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if filters.Proto != "tcp" {
+		t.Errorf("expected proto 'tcp', got %q", filters.Proto)
+	}
+}
+
+func TestBuildFilters_UDPOnly(t *testing.T) {
+	oldTCP, oldUDP := filterTCP, filterUDP
+	defer func() {
+		filterTCP, filterUDP = oldTCP, oldUDP
+	}()
+
+	filterTCP = false
+	filterUDP = true
+
+	filters, err := BuildFilters([]string{})
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if filters.Proto != "udp" {
+		t.Errorf("expected proto 'udp', got %q", filters.Proto)
+	}
+}
+
+func TestBuildFilters_ListenOnly(t *testing.T) {
+	oldListen, oldEstab := filterListen, filterEstab
+	defer func() {
+		filterListen, filterEstab = oldListen, oldEstab
+	}()
+
+	filterListen = true
+	filterEstab = false
+
+	filters, err := BuildFilters([]string{})
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if filters.State != "LISTEN" {
+		t.Errorf("expected state 'LISTEN', got %q", filters.State)
+	}
+}
+
+func TestBuildFilters_EstablishedOnly(t *testing.T) {
+	oldListen, oldEstab := filterListen, filterEstab
+	defer func() {
+		filterListen, filterEstab = oldListen, oldEstab
+	}()
+
+	filterListen = false
+	filterEstab = true
+
+	filters, err := BuildFilters([]string{})
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if filters.State != "ESTABLISHED" {
+		t.Errorf("expected state 'ESTABLISHED', got %q", filters.State)
+	}
+}
+
+func TestBuildFilters_IPv4Flag(t *testing.T) {
+	oldIPv4 := filterIPv4
+	defer func() {
+		filterIPv4 = oldIPv4
+	}()
+
+	filterIPv4 = true
+
+	filters, err := BuildFilters([]string{})
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if !filters.IPv4 {
+		t.Error("expected IPv4 to be true")
+	}
+}
+
+func TestBuildFilters_IPv6Flag(t *testing.T) {
+	oldIPv6 := filterIPv6
+	defer func() {
+		filterIPv6 = oldIPv6
+	}()
+
+	filterIPv6 = true
+
+	filters, err := BuildFilters([]string{})
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if !filters.IPv6 {
+		t.Error("expected IPv6 to be true")
+	}
+}
+
+func TestBuildFilters_CombinedArgsAndFlags(t *testing.T) {
+	oldTCP := filterTCP
+	defer func() {
+		filterTCP = oldTCP
+	}()
+
+	filterTCP = true
+
+	filters, err := BuildFilters([]string{"lport=80"})
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if filters.Proto != "tcp" {
+		t.Errorf("expected proto 'tcp', got %q", filters.Proto)
+	}
+	if filters.Lport != 80 {
+		t.Errorf("expected lport 80, got %d", filters.Lport)
+	}
+}
+
+func TestRuntime_PreWarmDNS(t *testing.T) {
+	rt := &Runtime{
+		Connections: []collector.Connection{
+			{Laddr: "127.0.0.1", Raddr: "192.168.1.1"},
+			{Laddr: "127.0.0.1", Raddr: "10.0.0.1"},
+		},
+	}
+
+	// should not panic
+	rt.PreWarmDNS()
+}
+
+func TestRuntime_PreWarmDNS_Empty(t *testing.T) {
+	rt := &Runtime{
+		Connections: []collector.Connection{},
+	}
+
+	// should not panic with empty connections
+	rt.PreWarmDNS()
+}
+
+func TestRuntime_SortConnections(t *testing.T) {
+	rt := &Runtime{
+		Connections: []collector.Connection{
+			{Lport: 443},
+			{Lport: 80},
+			{Lport: 8080},
+		},
+	}
+
+	rt.SortConnections(collector.SortOptions{
+		Field:     collector.SortByLport,
+		Direction: collector.SortAsc,
+	})
+
+	if rt.Connections[0].Lport != 80 {
+		t.Errorf("expected first connection to have lport 80, got %d", rt.Connections[0].Lport)
+	}
+	if rt.Connections[1].Lport != 443 {
+		t.Errorf("expected second connection to have lport 443, got %d", rt.Connections[1].Lport)
+	}
+	if rt.Connections[2].Lport != 8080 {
+		t.Errorf("expected third connection to have lport 8080, got %d", rt.Connections[2].Lport)
+	}
+}
+
+func TestRuntime_SortConnections_Desc(t *testing.T) {
+	rt := &Runtime{
+		Connections: []collector.Connection{
+			{Lport: 80},
+			{Lport: 443},
+			{Lport: 8080},
+		},
+	}
+
+	rt.SortConnections(collector.SortOptions{
+		Field:     collector.SortByLport,
+		Direction: collector.SortDesc,
+	})
+
+	if rt.Connections[0].Lport != 8080 {
+		t.Errorf("expected first connection to have lport 8080, got %d", rt.Connections[0].Lport)
+	}
+}
+
+func TestApplyFilter_AllKeys(t *testing.T) {
+	tests := []struct {
+		key      string
+		value    string
+		validate func(t *testing.T, f *collector.FilterOptions)
+	}{
+		{"proto", "tcp", func(t *testing.T, f *collector.FilterOptions) {
+			if f.Proto != "tcp" {
+				t.Errorf("proto: expected 'tcp', got %q", f.Proto)
+			}
+		}},
+		{"state", "LISTEN", func(t *testing.T, f *collector.FilterOptions) {
+			if f.State != "LISTEN" {
+				t.Errorf("state: expected 'LISTEN', got %q", f.State)
+			}
+		}},
+		{"pid", "100", func(t *testing.T, f *collector.FilterOptions) {
+			if f.Pid != 100 {
+				t.Errorf("pid: expected 100, got %d", f.Pid)
+			}
+		}},
+		{"proc", "nginx", func(t *testing.T, f *collector.FilterOptions) {
+			if f.Proc != "nginx" {
+				t.Errorf("proc: expected 'nginx', got %q", f.Proc)
+			}
+		}},
+		{"lport", "80", func(t *testing.T, f *collector.FilterOptions) {
+			if f.Lport != 80 {
+				t.Errorf("lport: expected 80, got %d", f.Lport)
+			}
+		}},
+		{"rport", "443", func(t *testing.T, f *collector.FilterOptions) {
+			if f.Rport != 443 {
+				t.Errorf("rport: expected 443, got %d", f.Rport)
+			}
+		}},
+		{"laddr", "127.0.0.1", func(t *testing.T, f *collector.FilterOptions) {
+			if f.Laddr != "127.0.0.1" {
+				t.Errorf("laddr: expected '127.0.0.1', got %q", f.Laddr)
+			}
+		}},
+		{"raddr", "8.8.8.8", func(t *testing.T, f *collector.FilterOptions) {
+			if f.Raddr != "8.8.8.8" {
+				t.Errorf("raddr: expected '8.8.8.8', got %q", f.Raddr)
+			}
+		}},
+		{"contains", "test", func(t *testing.T, f *collector.FilterOptions) {
+			if f.Contains != "test" {
+				t.Errorf("contains: expected 'test', got %q", f.Contains)
+			}
+		}},
+		{"if", "eth0", func(t *testing.T, f *collector.FilterOptions) {
+			if f.Interface != "eth0" {
+				t.Errorf("interface: expected 'eth0', got %q", f.Interface)
+			}
+		}},
+		{"mark", "0xff", func(t *testing.T, f *collector.FilterOptions) {
+			if f.Mark != "0xff" {
+				t.Errorf("mark: expected '0xff', got %q", f.Mark)
+			}
+		}},
+		{"namespace", "ns1", func(t *testing.T, f *collector.FilterOptions) {
+			if f.Namespace != "ns1" {
+				t.Errorf("namespace: expected 'ns1', got %q", f.Namespace)
+			}
+		}},
+		{"inode", "12345", func(t *testing.T, f *collector.FilterOptions) {
+			if f.Inode != 12345 {
+				t.Errorf("inode: expected 12345, got %d", f.Inode)
+			}
+		}},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.key, func(t *testing.T) {
+			filters := &collector.FilterOptions{}
+			err := applyFilter(filters, tt.key, tt.value)
+			if err != nil {
+				t.Fatalf("unexpected error: %v", err)
+			}
+			tt.validate(t, filters)
+		})
+	}
+}
+

cmd/stats.go

@@ -8,7 +8,6 @@ import (
 	"log"
 	"os"
 	"os/signal"
-	"snitch/internal/collector"
 	"sort"
 	"strconv"
 	"strings"
@@ -17,6 +16,9 @@ import (
 	"time"
 
 	"github.com/spf13/cobra"
+
+	"github.com/karol-broda/snitch/internal/collector"
+	"github.com/karol-broda/snitch/internal/errutil"
 )
 
 type StatsData struct {
@@ -227,19 +229,19 @@ func printStatsCSV(stats *StatsData, headers bool) {
 
 func printStatsTable(stats *StatsData, headers bool) {
 	w := tabwriter.NewWriter(os.Stdout, 0, 0, 3, ' ', 0)
-	defer w.Flush()
+	defer errutil.Flush(w)
 
 	if headers {
-		fmt.Fprintf(w, "TIMESTAMP\t%s\n", stats.Timestamp.Format(time.RFC3339))
-		fmt.Fprintf(w, "TOTAL CONNECTIONS\t%d\n", stats.Total)
-		fmt.Fprintln(w)
+		errutil.Ignore(fmt.Fprintf(w, "TIMESTAMP\t%s\n", stats.Timestamp.Format(time.RFC3339)))
+		errutil.Ignore(fmt.Fprintf(w, "TOTAL CONNECTIONS\t%d\n", stats.Total))
+		errutil.Ignore(fmt.Fprintln(w))
 	}
 
 	// Protocol breakdown
 	if len(stats.ByProto) > 0 {
 		if headers {
-			fmt.Fprintln(w, "BY PROTOCOL:")
-			fmt.Fprintln(w, "PROTO\tCOUNT")
+			errutil.Ignore(fmt.Fprintln(w, "BY PROTOCOL:"))
+			errutil.Ignore(fmt.Fprintln(w, "PROTO\tCOUNT"))
 		}
 		protocols := make([]string, 0, len(stats.ByProto))
 		for proto := range stats.ByProto {
@@ -247,16 +249,16 @@ func printStatsTable(stats *StatsData, headers bool) {
 		}
 		sort.Strings(protocols)
 		for _, proto := range protocols {
-			fmt.Fprintf(w, "%s\t%d\n", strings.ToUpper(proto), stats.ByProto[proto])
+			errutil.Ignore(fmt.Fprintf(w, "%s\t%d\n", strings.ToUpper(proto), stats.ByProto[proto]))
 		}
-		fmt.Fprintln(w)
+		errutil.Ignore(fmt.Fprintln(w))
 	}
 
 	// State breakdown
 	if len(stats.ByState) > 0 {
 		if headers {
-			fmt.Fprintln(w, "BY STATE:")
-			fmt.Fprintln(w, "STATE\tCOUNT")
+			errutil.Ignore(fmt.Fprintln(w, "BY STATE:"))
+			errutil.Ignore(fmt.Fprintln(w, "STATE\tCOUNT"))
 		}
 		states := make([]string, 0, len(stats.ByState))
 		for state := range stats.ByState {
@@ -264,16 +266,16 @@ func printStatsTable(stats *StatsData, headers bool) {
 		}
 		sort.Strings(states)
 		for _, state := range states {
-			fmt.Fprintf(w, "%s\t%d\n", state, stats.ByState[state])
+			errutil.Ignore(fmt.Fprintf(w, "%s\t%d\n", state, stats.ByState[state]))
 		}
-		fmt.Fprintln(w)
+		errutil.Ignore(fmt.Fprintln(w))
 	}
 
 	// Process breakdown (top 10)
 	if len(stats.ByProc) > 0 {
 		if headers {
-			fmt.Fprintln(w, "BY PROCESS (TOP 10):")
-			fmt.Fprintln(w, "PID\tPROCESS\tCOUNT")
+			errutil.Ignore(fmt.Fprintln(w, "BY PROCESS (TOP 10):"))
+			errutil.Ignore(fmt.Fprintln(w, "PID\tPROCESS\tCOUNT"))
 		}
 		limit := 10
 		if len(stats.ByProc) < limit {
@@ -281,7 +283,7 @@ func printStatsTable(stats *StatsData, headers bool) {
 		}
 		for i := 0; i < limit; i++ {
 			proc := stats.ByProc[i]
-			fmt.Fprintf(w, "%d\t%s\t%d\n", proc.PID, proc.Process, proc.Count)
+			errutil.Ignore(fmt.Fprintf(w, "%d\t%s\t%d\n", proc.PID, proc.Process, proc.Count))
 		}
 	}
 }

cmd/themes.go

@@ -0,0 +1,24 @@
+package cmd
+
+import (
+	"fmt"
+
+	"github.com/karol-broda/snitch/internal/theme"
+	"github.com/spf13/cobra"
+)
+
+var themesCmd = &cobra.Command{
+	Use:   "themes",
+	Short: "List available themes",
+	Run: func(cmd *cobra.Command, args []string) {
+		fmt.Printf("Available themes (default: %s):\n\n", theme.DefaultTheme)
+		for _, name := range theme.ListThemes() {
+			fmt.Printf("  %s\n", name)
+		}
+	},
+}
+
+func init() {
+	rootCmd.AddCommand(themesCmd)
+}
+

cmd/top.go

@@ -2,11 +2,12 @@ package cmd
 
 import (
 	"log"
-	"snitch/internal/config"
-	"snitch/internal/tui"
 	"time"
 
 	tea "github.com/charmbracelet/bubbletea"
+	"github.com/karol-broda/snitch/internal/config"
+	"github.com/karol-broda/snitch/internal/resolver"
+	"github.com/karol-broda/snitch/internal/tui"
 	"github.com/spf13/cobra"
 )
 
@@ -27,9 +28,16 @@ var topCmd = &cobra.Command{
 			theme = cfg.Defaults.Theme
 		}
 
+		// configure resolver with cache setting
+		effectiveNoCache := noCache || !cfg.Defaults.DNSCache
+		resolver.SetNoCache(effectiveNoCache)
+
 		opts := tui.Options{
 			Theme:        theme,
 			Interval:     topInterval,
+			ResolveAddrs: resolveAddrs,
+			ResolvePorts: resolvePorts,
+			NoCache:      effectiveNoCache,
 		}
 
 		// if any filter flag is set, use exclusive mode
@@ -56,9 +64,10 @@ func init() {
 	cfg := config.Get()
 
 	// top-specific flags
-	topCmd.Flags().StringVar(&topTheme, "theme", cfg.Defaults.Theme, "Theme for TUI (dark, light, mono, auto)")
+	topCmd.Flags().StringVar(&topTheme, "theme", cfg.Defaults.Theme, "Theme for TUI (see 'snitch themes')")
 	topCmd.Flags().DurationVarP(&topInterval, "interval", "i", time.Second, "Refresh interval")
 
-	// shared filter flags
+	// shared flags
 	addFilterFlags(topCmd)
+	addResolutionFlags(topCmd)
 }

cmd/trace.go

@@ -7,12 +7,14 @@ import (
 	"log"
 	"os"
 	"os/signal"
-	"snitch/internal/collector"
-	"snitch/internal/resolver"
 	"strings"
 	"syscall"
 	"time"
 
+	"github.com/karol-broda/snitch/internal/collector"
+	"github.com/karol-broda/snitch/internal/config"
+	"github.com/karol-broda/snitch/internal/resolver"
+
 	"github.com/spf13/cobra"
 )
 
@@ -26,7 +28,6 @@ var (
 	traceInterval     time.Duration
 	traceCount        int
 	traceOutputFormat string
-	traceNumeric     bool
 	traceTimestamp    bool
 )
 
@@ -47,6 +48,12 @@ Available filters:
 }
 
 func runTraceCommand(args []string) {
+	cfg := config.Get()
+	
+	// configure resolver with cache setting
+	effectiveNoCache := noCache || !cfg.Defaults.DNSCache
+	resolver.SetNoCache(effectiveNoCache)
+
 	filters, err := BuildFilters(args)
 	if err != nil {
 		log.Fatalf("Error parsing filters: %v", err)
@@ -180,14 +187,16 @@ func printTraceEventHuman(event TraceEvent) {
 	lportStr := fmt.Sprintf("%d", conn.Lport)
 	rportStr := fmt.Sprintf("%d", conn.Rport)
 	
-	// Handle name resolution based on numeric flag
-	if !traceNumeric {
+	// apply name resolution
+	if resolveAddrs {
 		if resolvedLaddr := resolver.ResolveAddr(conn.Laddr); resolvedLaddr != conn.Laddr {
 			laddr = resolvedLaddr
 		}
 		if resolvedRaddr := resolver.ResolveAddr(conn.Raddr); resolvedRaddr != conn.Raddr && conn.Raddr != "*" && conn.Raddr != "" {
 			raddr = resolvedRaddr
 		}
+	}
+	if resolvePorts {
 		if resolvedLport := resolver.ResolvePort(conn.Lport, conn.Proto); resolvedLport != fmt.Sprintf("%d", conn.Lport) {
 			lportStr = resolvedLport
 		}
@@ -225,9 +234,9 @@ func init() {
 	traceCmd.Flags().DurationVarP(&traceInterval, "interval", "i", time.Second, "Polling interval (e.g., 500ms, 2s)")
 	traceCmd.Flags().IntVarP(&traceCount, "count", "c", 0, "Number of events to capture (0 = unlimited)")
 	traceCmd.Flags().StringVarP(&traceOutputFormat, "output", "o", "human", "Output format (human, json)")
-	traceCmd.Flags().BoolVarP(&traceNumeric, "numeric", "n", false, "Don't resolve hostnames")
 	traceCmd.Flags().BoolVar(&traceTimestamp, "ts", false, "Include timestamp in output")
 
-	// shared filter flags
+	// shared flags
 	addFilterFlags(traceCmd)
+	addResolutionFlags(traceCmd)
 }

cmd/upgrade.go

@@ -0,0 +1,689 @@
+package cmd
+
+import (
+	"archive/tar"
+	"compress/gzip"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"regexp"
+	"runtime"
+	"strconv"
+	"strings"
+
+	"github.com/fatih/color"
+	"github.com/spf13/cobra"
+
+	"github.com/karol-broda/snitch/internal/errutil"
+	"github.com/karol-broda/snitch/internal/tui"
+)
+
+const (
+	repoOwner = "karol-broda"
+	repoName  = "snitch"
+	githubAPI = "https://api.github.com"
+	firstUpgradeVersion = "0.1.8"
+)
+
+var (
+	upgradeYes     bool
+	upgradeVersion string
+)
+
+var upgradeCmd = &cobra.Command{
+	Use:   "upgrade",
+	Short: "Check for updates and optionally upgrade snitch",
+	Long: `Check for available updates and show upgrade instructions.
+
+Use --yes to perform an in-place upgrade automatically.
+Use --version to install a specific version.`,
+	RunE: runUpgrade,
+}
+
+func init() {
+	upgradeCmd.Flags().BoolVarP(&upgradeYes, "yes", "y", false, "Perform the upgrade automatically")
+	upgradeCmd.Flags().StringVarP(&upgradeVersion, "version", "v", "", "Install a specific version (e.g., v0.1.7)")
+	rootCmd.AddCommand(upgradeCmd)
+}
+
+type githubRelease struct {
+	TagName string `json:"tag_name"`
+	HTMLURL string `json:"html_url"`
+}
+
+type githubCommit struct {
+	SHA string `json:"sha"`
+}
+
+type githubCompare struct {
+	Status      string `json:"status"`
+	AheadBy     int    `json:"ahead_by"`
+	BehindBy    int    `json:"behind_by"`
+	TotalCommits int   `json:"total_commits"`
+}
+
+func runUpgrade(cmd *cobra.Command, args []string) error {
+	current := Version
+	nixInstall := isNixInstall()
+	nixVersion := isNixVersion(current)
+
+	if upgradeVersion != "" {
+		if nixInstall || nixVersion {
+			return handleNixSpecificVersion(current, upgradeVersion)
+		}
+		return handleSpecificVersion(current, upgradeVersion)
+	}
+
+	latest, err := fetchLatestVersion()
+	if err != nil {
+		return fmt.Errorf("failed to check for updates: %w", err)
+	}
+
+	if nixInstall || nixVersion {
+		return handleNixUpgrade(current, latest)
+	}
+
+	currentClean := strings.TrimPrefix(current, "v")
+	latestClean := strings.TrimPrefix(latest, "v")
+
+	printVersionComparison(current, latest)
+
+	if currentClean == latestClean {
+		green := color.New(color.FgGreen)
+		errutil.Println(green, tui.SymbolSuccess+" you are running the latest version")
+		return nil
+	}
+
+	if current == "dev" {
+		yellow := color.New(color.FgYellow)
+		errutil.Println(yellow, tui.SymbolWarning+" you are running a development build")
+		fmt.Println()
+		fmt.Println("use one of the methods below to install a release version:")
+		fmt.Println()
+		printUpgradeInstructions()
+		return nil
+	}
+
+	green := color.New(color.FgGreen, color.Bold)
+	errutil.Printf(green, tui.SymbolSuccess+" update available: %s "+tui.SymbolArrowRight+" %s\n", current, latest)
+	fmt.Println()
+
+	if !upgradeYes {
+		printUpgradeInstructions()
+		fmt.Println()
+		faint := color.New(color.Faint)
+		cmdStyle := color.New(color.FgCyan)
+		errutil.Print(faint, "  in-place      ")
+		errutil.Println(cmdStyle, "snitch upgrade --yes")
+		return nil
+	}
+
+	return performUpgrade(latest)
+}
+
+func handleSpecificVersion(current, target string) error {
+	if !strings.HasPrefix(target, "v") {
+		target = "v" + target
+	}
+	targetClean := strings.TrimPrefix(target, "v")
+
+	printVersionComparisonTarget(current, target)
+
+	if isVersionLower(targetClean, firstUpgradeVersion) {
+		yellow := color.New(color.FgYellow)
+		errutil.Printf(yellow, tui.SymbolWarning+" warning: the upgrade command was introduced in v%s\n", firstUpgradeVersion)
+		faint := color.New(color.Faint)
+		errutil.Printf(faint, "  version %s does not include this command\n", target)
+		errutil.Println(faint, "  you will need to use other methods to upgrade from that version")
+		fmt.Println()
+	}
+
+	currentClean := strings.TrimPrefix(current, "v")
+	if currentClean == targetClean {
+		green := color.New(color.FgGreen)
+		errutil.Println(green, tui.SymbolSuccess+" you are already running this version")
+		return nil
+	}
+
+	if !upgradeYes {
+		faint := color.New(color.Faint)
+		cmdStyle := color.New(color.FgCyan)
+		if isVersionLower(targetClean, currentClean) {
+			yellow := color.New(color.FgYellow)
+			errutil.Printf(yellow, tui.SymbolArrowDown+" this will downgrade from %s to %s\n", current, target)
+		} else {
+			green := color.New(color.FgGreen)
+			errutil.Printf(green, tui.SymbolArrowUp+" this will upgrade from %s to %s\n", current, target)
+		}
+		fmt.Println()
+		errutil.Print(faint, "run ")
+		errutil.Printf(cmdStyle, "snitch upgrade --version %s --yes", target)
+		errutil.Println(faint, " to proceed")
+		return nil
+	}
+
+	return performUpgrade(target)
+}
+
+func handleNixUpgrade(current, latest string) error {
+	faint := color.New(color.Faint)
+	version := color.New(color.FgCyan)
+
+	currentCommit := extractCommitFromVersion(current)
+	dirty := isNixDirty(current)
+
+	errutil.Print(faint, "current  ")
+	errutil.Print(version, current)
+	if currentCommit != "" {
+		errutil.Printf(faint, " (commit %s)", currentCommit)
+	}
+	fmt.Println()
+
+	errutil.Print(faint, "latest   ")
+	errutil.Println(version, latest)
+	fmt.Println()
+
+	if dirty {
+		yellow := color.New(color.FgYellow)
+		errutil.Println(yellow, tui.SymbolWarning+" you are running a dirty nix build (uncommitted changes)")
+		fmt.Println()
+		printNixUpgradeInstructions()
+		return nil
+	}
+
+	if currentCommit == "" {
+		yellow := color.New(color.FgYellow)
+		errutil.Println(yellow, tui.SymbolWarning+" this is a nix installation")
+		errutil.Println(faint, "  nix store is immutable; use nix commands to upgrade")
+		fmt.Println()
+		printNixUpgradeInstructions()
+		return nil
+	}
+
+	releaseCommit, err := fetchCommitForTag(latest)
+	if err != nil {
+		errutil.Printf(faint, "  (could not fetch release commit: %v)\n", err)
+		fmt.Println()
+		yellow := color.New(color.FgYellow)
+		errutil.Println(yellow, tui.SymbolWarning+" this is a nix installation")
+		errutil.Println(faint, "  nix store is immutable; use nix commands to upgrade")
+		fmt.Println()
+		printNixUpgradeInstructions()
+		return nil
+	}
+
+	releaseShort := releaseCommit
+	if len(releaseShort) > 7 {
+		releaseShort = releaseShort[:7]
+	}
+
+	if strings.HasPrefix(releaseCommit, currentCommit) || strings.HasPrefix(currentCommit, releaseShort) {
+		green := color.New(color.FgGreen)
+		errutil.Printf(green, tui.SymbolSuccess+" you are running %s (commit %s)\n", latest, releaseShort)
+		return nil
+	}
+
+	comparison, err := compareCommits(latest, currentCommit)
+	if err != nil {
+		green := color.New(color.FgGreen, color.Bold)
+		errutil.Printf(green, tui.SymbolSuccess+" update available: %s "+tui.SymbolArrowRight+" %s\n", currentCommit, latest)
+		errutil.Printf(faint, "  your commit: %s\n", currentCommit)
+		errutil.Printf(faint, "  release:     %s (%s)\n", releaseShort, latest)
+		fmt.Println()
+		yellow := color.New(color.FgYellow)
+		errutil.Println(yellow, tui.SymbolWarning+" this is a nix installation")
+		errutil.Println(faint, "  nix store is immutable; use nix commands to upgrade")
+		fmt.Println()
+		printNixUpgradeInstructions()
+		return nil
+	}
+
+	if comparison.AheadBy > 0 {
+		cyan := color.New(color.FgCyan)
+		errutil.Printf(cyan, tui.SymbolArrowUp+" you are %d commit(s) ahead of %s\n", comparison.AheadBy, latest)
+		errutil.Printf(faint, "  your commit: %s\n", currentCommit)
+		errutil.Printf(faint, "  release:     %s (%s)\n", releaseShort, latest)
+		fmt.Println()
+		errutil.Println(faint, "you are running a newer build than the latest release")
+		return nil
+	}
+
+	if comparison.BehindBy > 0 {
+		green := color.New(color.FgGreen, color.Bold)
+		errutil.Printf(green, tui.SymbolSuccess+" update available: %d commit(s) behind %s\n", comparison.BehindBy, latest)
+		errutil.Printf(faint, "  your commit: %s\n", currentCommit)
+		errutil.Printf(faint, "  release:     %s (%s)\n", releaseShort, latest)
+		fmt.Println()
+		yellow := color.New(color.FgYellow)
+		errutil.Println(yellow, tui.SymbolWarning+" this is a nix installation")
+		errutil.Println(faint, "  nix store is immutable; use nix commands to upgrade")
+		fmt.Println()
+		printNixUpgradeInstructions()
+		return nil
+	}
+
+	green := color.New(color.FgGreen)
+	errutil.Printf(green, tui.SymbolSuccess+" you are running %s (commit %s)\n", latest, releaseShort)
+	return nil
+}
+
+func handleNixSpecificVersion(current, target string) error {
+	if !strings.HasPrefix(target, "v") {
+		target = "v" + target
+	}
+
+	printVersionComparisonTarget(current, target)
+
+	yellow := color.New(color.FgYellow)
+	errutil.Println(yellow, tui.SymbolWarning+" this is a nix installation")
+	faint := color.New(color.Faint)
+	errutil.Println(faint, "  nix store is immutable; in-place upgrades are not supported")
+	fmt.Println()
+
+	bold := color.New(color.Bold)
+	cmd := color.New(color.FgCyan)
+
+	errutil.Println(bold, "to install a specific version with nix:")
+	fmt.Println()
+
+	errutil.Print(faint, "  specific ref    ")
+	errutil.Printf(cmd, "nix profile install github:%s/%s/%s\n", repoOwner, repoName, target)
+
+	errutil.Print(faint, "  latest          ")
+	errutil.Printf(cmd, "nix profile install github:%s/%s\n", repoOwner, repoName)
+
+	return nil
+}
+
+func isVersionLower(v1, v2 string) bool {
+	parts1 := parseVersion(v1)
+	parts2 := parseVersion(v2)
+
+	for i := 0; i < 3; i++ {
+		if parts1[i] < parts2[i] {
+			return true
+		}
+		if parts1[i] > parts2[i] {
+			return false
+		}
+	}
+	return false
+}
+
+func parseVersion(v string) [3]int {
+	var parts [3]int
+	segments := strings.Split(v, ".")
+
+	for i := 0; i < len(segments) && i < 3; i++ {
+		n, err := strconv.Atoi(segments[i])
+		if err == nil {
+			parts[i] = n
+		}
+	}
+	return parts
+}
+
+func fetchLatestVersion() (string, error) {
+	url := fmt.Sprintf("%s/repos/%s/%s/releases/latest", githubAPI, repoOwner, repoName)
+
+	resp, err := http.Get(url)
+	if err != nil {
+		return "", err
+	}
+	defer errutil.Close(resp.Body)
+
+	if resp.StatusCode != http.StatusOK {
+		return "", fmt.Errorf("github api returned status %d", resp.StatusCode)
+	}
+
+	var release githubRelease
+	if err := json.NewDecoder(resp.Body).Decode(&release); err != nil {
+		return "", err
+	}
+
+	if release.TagName == "" {
+		return "", fmt.Errorf("no releases found")
+	}
+
+	return release.TagName, nil
+}
+
+func printVersionComparison(current, latest string) {
+	faint := color.New(color.Faint)
+	version := color.New(color.FgCyan)
+
+	errutil.Print(faint, "current  ")
+	errutil.Println(version, current)
+	errutil.Print(faint, "latest   ")
+	errutil.Println(version, latest)
+	fmt.Println()
+}
+
+func printVersionComparisonTarget(current, target string) {
+	faint := color.New(color.Faint)
+	version := color.New(color.FgCyan)
+
+	errutil.Print(faint, "current  ")
+	errutil.Println(version, current)
+	errutil.Print(faint, "target   ")
+	errutil.Println(version, target)
+	fmt.Println()
+}
+
+func printUpgradeInstructions() {
+	bold := color.New(color.Bold)
+	faint := color.New(color.Faint)
+	cmd := color.New(color.FgCyan)
+
+	errutil.Println(bold, "upgrade options:")
+	fmt.Println()
+
+	errutil.Print(faint, "  go install    ")
+	errutil.Printf(cmd, "go install github.com/%s/%s@latest\n", repoOwner, repoName)
+
+	errutil.Print(faint, "  shell script  ")
+	errutil.Printf(cmd, "curl -sSL https://raw.githubusercontent.com/%s/%s/master/install.sh | sh\n", repoOwner, repoName)
+
+	errutil.Print(faint, "  arch (aur)    ")
+	errutil.Println(cmd, "yay -S snitch-bin")
+
+	errutil.Print(faint, "  nix           ")
+	errutil.Printf(cmd, "nix profile upgrade --inputs-from github:%s/%s\n", repoOwner, repoName)
+}
+
+func performUpgrade(version string) error {
+	execPath, err := os.Executable()
+	if err != nil {
+		return fmt.Errorf("failed to get executable path: %w", err)
+	}
+
+	execPath, err = filepath.EvalSymlinks(execPath)
+	if err != nil {
+		return fmt.Errorf("failed to resolve executable path: %w", err)
+	}
+
+	if strings.HasPrefix(execPath, "/nix/store/") {
+		yellow := color.New(color.FgYellow)
+		errutil.Println(yellow, tui.SymbolWarning+" cannot perform in-place upgrade for nix installation")
+		fmt.Println()
+		printNixUpgradeInstructions()
+		return nil
+	}
+
+	goos := runtime.GOOS
+	goarch := runtime.GOARCH
+
+	versionClean := strings.TrimPrefix(version, "v")
+	archiveName := fmt.Sprintf("%s_%s_%s_%s.tar.gz", repoName, versionClean, goos, goarch)
+	downloadURL := fmt.Sprintf("https://github.com/%s/%s/releases/download/%s/%s",
+		repoOwner, repoName, version, archiveName)
+
+	faint := color.New(color.Faint)
+	cyan := color.New(color.FgCyan)
+	errutil.Print(faint, tui.SymbolDownload+" downloading ")
+	errutil.Printf(cyan, "%s", archiveName)
+	errutil.Println(faint, "...")
+
+	resp, err := http.Get(downloadURL)
+	if err != nil {
+		return fmt.Errorf("failed to download: %w", err)
+	}
+	defer errutil.Close(resp.Body)
+
+	if resp.StatusCode != http.StatusOK {
+		return fmt.Errorf("download failed with status %d", resp.StatusCode)
+	}
+
+	tmpDir, err := os.MkdirTemp("", "snitch-upgrade-*")
+	if err != nil {
+		return fmt.Errorf("failed to create temp directory: %w", err)
+	}
+	defer errutil.RemoveAll(tmpDir)
+
+	binaryPath, err := extractBinaryFromTarGz(resp.Body, tmpDir)
+	if err != nil {
+		return fmt.Errorf("failed to extract binary: %w", err)
+	}
+
+	if goos == "darwin" {
+		removeQuarantine(binaryPath)
+	}
+
+	// check if we can write to the target location
+	targetDir := filepath.Dir(execPath)
+	if !isWritable(targetDir) {
+		yellow := color.New(color.FgYellow)
+		cmdStyle := color.New(color.FgCyan)
+
+		errutil.Printf(yellow, tui.SymbolWarning+" elevated permissions required to install to %s\n", targetDir)
+		fmt.Println()
+		errutil.Println(faint, "run with sudo or install to a user-writable location:")
+		fmt.Println()
+		errutil.Print(faint, "  sudo         ")
+		errutil.Println(cmdStyle, "sudo snitch upgrade --yes")
+		errutil.Print(faint, "  custom dir   ")
+		errutil.Printf(cmdStyle, "curl -sSL https://raw.githubusercontent.com/%s/%s/master/install.sh | INSTALL_DIR=~/.local/bin sh\n",
+			repoOwner, repoName)
+		return nil
+	}
+
+	// replace the binary
+	backupPath := execPath + ".bak"
+	if err := os.Rename(execPath, backupPath); err != nil {
+		return fmt.Errorf("failed to backup current binary: %w", err)
+	}
+
+	if err := copyFile(binaryPath, execPath); err != nil {
+		// try to restore backup
+		if restoreErr := os.Rename(backupPath, execPath); restoreErr != nil {
+			return fmt.Errorf("failed to install new binary and restore backup: %w (restore error: %v)", err, restoreErr)
+		}
+		return fmt.Errorf("failed to install new binary: %w", err)
+	}
+
+	if err := os.Chmod(execPath, 0755); err != nil {
+		return fmt.Errorf("failed to set executable permissions: %w", err)
+	}
+
+	if err := os.Remove(backupPath); err != nil {
+		// non-fatal, just warn
+		yellow := color.New(color.FgYellow)
+		errutil.Fprintf(yellow, os.Stderr, tui.SymbolWarning+" warning: failed to remove backup file %s: %v\n", backupPath, err)
+	}
+
+	green := color.New(color.FgGreen, color.Bold)
+	errutil.Printf(green, tui.SymbolSuccess+" successfully upgraded to %s\n", version)
+	return nil
+}
+
+func extractBinaryFromTarGz(r io.Reader, destDir string) (string, error) {
+	gzr, err := gzip.NewReader(r)
+	if err != nil {
+		return "", err
+	}
+	defer errutil.Close(gzr)
+
+	tr := tar.NewReader(gzr)
+
+	for {
+		header, err := tr.Next()
+		if err == io.EOF {
+			break
+		}
+		if err != nil {
+			return "", err
+		}
+
+		if header.Typeflag != tar.TypeReg {
+			continue
+		}
+
+		// look for the snitch binary
+		name := filepath.Base(header.Name)
+		if name != repoName {
+			continue
+		}
+
+		destPath := filepath.Join(destDir, name)
+		outFile, err := os.Create(destPath)
+		if err != nil {
+			return "", err
+		}
+
+		if _, err := io.Copy(outFile, tr); err != nil {
+			errutil.Close(outFile)
+			return "", err
+		}
+		errutil.Close(outFile)
+
+		return destPath, nil
+	}
+
+	return "", fmt.Errorf("binary not found in archive")
+}
+
+func isWritable(path string) bool {
+	testFile := filepath.Join(path, ".snitch-write-test")
+	f, err := os.Create(testFile)
+	if err != nil {
+		return false
+	}
+	errutil.Close(f)
+	errutil.Remove(testFile)
+	return true
+}
+
+func copyFile(src, dst string) error {
+	srcFile, err := os.Open(src)
+	if err != nil {
+		return err
+	}
+	defer errutil.Close(srcFile)
+
+	dstFile, err := os.Create(dst)
+	if err != nil {
+		return err
+	}
+	defer errutil.Close(dstFile)
+
+	if _, err := io.Copy(dstFile, srcFile); err != nil {
+		return err
+	}
+
+	return dstFile.Sync()
+}
+
+func removeQuarantine(path string) {
+	cmd := exec.Command("xattr", "-d", "com.apple.quarantine", path)
+	if err := cmd.Run(); err == nil {
+		faint := color.New(color.Faint)
+		errutil.Println(faint, "  removed macOS quarantine attribute")
+	}
+}
+
+func isNixInstall() bool {
+	execPath, err := os.Executable()
+	if err != nil {
+		return false
+	}
+
+	resolved, err := filepath.EvalSymlinks(execPath)
+	if err != nil {
+		return false
+	}
+
+	return strings.HasPrefix(resolved, "/nix/store/")
+}
+
+var nixVersionPattern = regexp.MustCompile(`^nix-([a-f0-9]+)(-dirty)?$`)
+var commitHashPattern = regexp.MustCompile(`^[a-f0-9]{7,40}$`)
+
+func isNixVersion(version string) bool {
+	if nixVersionPattern.MatchString(version) {
+		return true
+	}
+	if commitHashPattern.MatchString(version) {
+		return true
+	}
+	return false
+}
+
+func extractCommitFromVersion(version string) string {
+	matches := nixVersionPattern.FindStringSubmatch(version)
+	if len(matches) >= 2 {
+		return matches[1]
+	}
+	if commitHashPattern.MatchString(version) {
+		return version
+	}
+	return ""
+}
+
+func isNixDirty(version string) bool {
+	return strings.HasSuffix(version, "-dirty")
+}
+
+func fetchCommitForTag(tag string) (string, error) {
+	url := fmt.Sprintf("%s/repos/%s/%s/commits/%s", githubAPI, repoOwner, repoName, tag)
+
+	resp, err := http.Get(url)
+	if err != nil {
+		return "", err
+	}
+	defer errutil.Close(resp.Body)
+
+	if resp.StatusCode != http.StatusOK {
+		return "", fmt.Errorf("github api returned status %d", resp.StatusCode)
+	}
+
+	var commit githubCommit
+	if err := json.NewDecoder(resp.Body).Decode(&commit); err != nil {
+		return "", err
+	}
+
+	return commit.SHA, nil
+}
+
+func compareCommits(base, head string) (*githubCompare, error) {
+	url := fmt.Sprintf("%s/repos/%s/%s/compare/%s...%s", githubAPI, repoOwner, repoName, base, head)
+
+	resp, err := http.Get(url)
+	if err != nil {
+		return nil, err
+	}
+	defer errutil.Close(resp.Body)
+
+	if resp.StatusCode != http.StatusOK {
+		return nil, fmt.Errorf("github api returned status %d", resp.StatusCode)
+	}
+
+	var compare githubCompare
+	if err := json.NewDecoder(resp.Body).Decode(&compare); err != nil {
+		return nil, err
+	}
+
+	return &compare, nil
+}
+
+func printNixUpgradeInstructions() {
+	bold := color.New(color.Bold)
+	faint := color.New(color.Faint)
+	cmd := color.New(color.FgCyan)
+
+	errutil.Println(bold, "nix upgrade options:")
+	fmt.Println()
+
+	errutil.Print(faint, "  flake profile   ")
+	errutil.Printf(cmd, "nix profile install github:%s/%s\n", repoOwner, repoName)
+
+	errutil.Print(faint, "  flake update    ")
+	errutil.Println(cmd, "nix flake update snitch  (in your system/home-manager config)")
+
+	errutil.Print(faint, "  rebuild         ")
+	errutil.Println(cmd, "nixos-rebuild switch  or  home-manager switch")
+}
+

cmd/version.go

@@ -4,7 +4,10 @@ import (
 	"fmt"
 	"runtime"
 
+	"github.com/fatih/color"
 	"github.com/spf13/cobra"
+
+	"github.com/karol-broda/snitch/internal/errutil"
 )
 
 var (
@@ -17,11 +20,25 @@ var versionCmd = &cobra.Command{
 	Use:   "version",
 	Short: "Show version/build info",
 	Run: func(cmd *cobra.Command, args []string) {
-		fmt.Printf("snitch %s\n", Version)
-		fmt.Printf("  commit: %s\n", Commit)
-		fmt.Printf("  built:  %s\n", Date)
-		fmt.Printf("  go:     %s\n", runtime.Version())
-		fmt.Printf("  os:     %s/%s\n", runtime.GOOS, runtime.GOARCH)
+		bold := color.New(color.Bold)
+		cyan := color.New(color.FgCyan)
+		faint := color.New(color.Faint)
+
+		errutil.Print(bold, "snitch ")
+		errutil.Println(cyan, Version)
+		fmt.Println()
+
+		errutil.Print(faint, "  commit  ")
+		fmt.Println(Commit)
+
+		errutil.Print(faint, "  built   ")
+		fmt.Println(Date)
+
+		errutil.Print(faint, "  go      ")
+		fmt.Println(runtime.Version())
+
+		errutil.Print(faint, "  os      ")
+		fmt.Printf("%s/%s\n", runtime.GOOS, runtime.GOARCH)
 	},
 }
 

flake.lock

@@ -2,39 +2,23 @@
   "nodes": {
     "nixpkgs": {
       "locked": {
-        "lastModified": 1765687488,
-        "narHash": "sha256-7YAJ6xgBAQ/Nr+7MI13Tui1ULflgAdKh63m1tfYV7+M=",
+        "lastModified": 1766201043,
+        "narHash": "sha256-eplAP+rorKKd0gNjV3rA6+0WMzb1X1i16F5m5pASnjA=",
         "owner": "NixOS",
         "repo": "nixpkgs",
-        "rev": "d02bcc33948ca19b0aaa0213fe987ceec1f4ebe1",
+        "rev": "b3aad468604d3e488d627c0b43984eb60e75e782",
         "type": "github"
       },
       "original": {
         "owner": "NixOS",
-        "ref": "nixos-25.05",
+        "ref": "nixos-25.11",
         "repo": "nixpkgs",
         "type": "github"
       }
     },
     "root": {
       "inputs": {
-        "nixpkgs": "nixpkgs",
-        "systems": "systems"
-      }
-    },
-    "systems": {
-      "locked": {
-        "lastModified": 1681028828,
-        "narHash": "sha256-Vy1rq5AaRuLzOxct8nz4T6wlgyUR7zLU309k9mBC768=",
-        "owner": "nix-systems",
-        "repo": "default",
-        "rev": "da67096a3b9bf56a91d16901293e51ba5b49a27e",
-        "type": "github"
-      },
-      "original": {
-        "owner": "nix-systems",
-        "repo": "default",
-        "type": "github"
+        "nixpkgs": "nixpkgs"
       }
     }
   },

flake.nix

@@ -1,107 +1,110 @@
 {
   description = "snitch - a friendlier ss/netstat for humans";
 
-  inputs = {
-    nixpkgs.url = "github:NixOS/nixpkgs/nixos-25.05";
-    systems.url = "github:nix-systems/default";
-  };
+  inputs.nixpkgs.url = "github:NixOS/nixpkgs/nixos-25.11";
 
-  outputs = { self, nixpkgs, systems }:
+  outputs = { self, nixpkgs }:
     let
-      supportedSystems = import systems;
-      forAllSystems = f: nixpkgs.lib.genAttrs supportedSystems (system: f system);
+      systems = [ "x86_64-linux" "aarch64-linux" "x86_64-darwin" "aarch64-darwin" ];
+      eachSystem = nixpkgs.lib.genAttrs systems;
 
-      # go 1.25 overlay (required until nixpkgs has it)
-      goOverlay = final: prev:
+      # go 1.25 binary derivation (required until nixpkgs ships it)
+      mkGo125 = pkgs:
         let
           version = "1.25.0";
-          platformInfo = {
-            "x86_64-linux" = { suffix = "linux-amd64"; sri = "sha256-KFKvDLIKExObNEiZLmm4aOUO0Pih5ZQO4d6eGaEjthM="; };
-            "aarch64-linux" = { suffix = "linux-arm64"; sri = "sha256-Bd511plKJ4NpmBXuVTvVqTJ9i3mZHeNuOLZoYngvVK4="; };
-            "x86_64-darwin" = { suffix = "darwin-amd64"; sri = "sha256-W9YOgjA3BiwjB8cegRGAmGURZxTW9rQQWXz1B139gO8="; };
-            "aarch64-darwin" = { suffix = "darwin-arm64"; sri = "sha256-VEkyhEFW2Bcveij3fyrJwVojBGaYtiQ/YzsKCwDAdJw="; };
-          };
-          hostSystem = prev.stdenv.hostPlatform.system;
-          chosen = platformInfo.${hostSystem} or (throw "unsupported system: ${hostSystem}");
+          platform = {
+            "x86_64-linux" = { suffix = "linux-amd64"; hash = "sha256-KFKvDLIKExObNEiZLmm4aOUO0Pih5ZQO4d6eGaEjthM="; GOOS = "linux"; GOARCH = "amd64"; };
+            "aarch64-linux" = { suffix = "linux-arm64"; hash = "sha256-Bd511plKJ4NpmBXuVTvVqTJ9i3mZHeNuOLZoYngvVK4="; GOOS = "linux"; GOARCH = "arm64"; };
+            "x86_64-darwin" = { suffix = "darwin-amd64"; hash = "sha256-W9YOgjA3BiwjB8cegRGAmGURZxTW9rQQWXz1B139gO8="; GOOS = "darwin"; GOARCH = "amd64"; };
+            "aarch64-darwin" = { suffix = "darwin-arm64"; hash = "sha256-VEkyhEFW2Bcveij3fyrJwVojBGaYtiQ/YzsKCwDAdJw="; GOOS = "darwin"; GOARCH = "arm64"; };
+          }.${pkgs.stdenv.hostPlatform.system} or (throw "unsupported system: ${pkgs.stdenv.hostPlatform.system}");
         in
-        {
-          go_1_25 = prev.stdenvNoCC.mkDerivation {
+        pkgs.stdenv.mkDerivation {
           pname = "go";
           inherit version;
-            src = prev.fetchurl {
-              url = "https://go.dev/dl/go${version}.${chosen.suffix}.tar.gz";
-              hash = chosen.sri;
+          src = pkgs.fetchurl {
+            url = "https://go.dev/dl/go${version}.${platform.suffix}.tar.gz";
+            inherit (platform) hash;
           };
           dontBuild = true;
-            installPhase = ''
-              runHook preInstall
-              mkdir -p "$out"/{bin,share}
-              tar -C "$TMPDIR" -xzf "$src"
-              cp -a "$TMPDIR/go" "$out/share/go"
-              ln -s "$out/share/go/bin/go" "$out/bin/go"
-              ln -s "$out/share/go/bin/gofmt" "$out/bin/gofmt"
-              runHook postInstall
-            '';
           dontPatchELF = true;
           dontStrip = true;
+          installPhase = ''
+            runHook preInstall
+            mkdir -p $out/{bin,share/go}
+            tar -xzf $src --strip-components=1 -C $out/share/go
+            ln -s $out/share/go/bin/go $out/bin/go
+            ln -s $out/share/go/bin/gofmt $out/bin/gofmt
+            runHook postInstall
+          '';
+          passthru = {
+            inherit (platform) GOOS GOARCH;
           };
         };
-    in
-    {
-      overlays.default = final: prev: {
-        snitch = final.callPackage ./nix/package.nix { };
-      };
 
-      packages = forAllSystems (system:
+      pkgsFor = system: import nixpkgs { inherit system; };
+
+      mkSnitch = pkgs:
         let
-          pkgs = import nixpkgs {
-            inherit system;
-            overlays = [ goOverlay ];
-          };
+          rev = self.shortRev or self.dirtyShortRev or "unknown";
+          version = "nix-${rev}";
+          isDarwin = pkgs.stdenv.isDarwin;
+          go = mkGo125 pkgs;
+          buildGoModule = pkgs.buildGoModule.override { inherit go; };
         in
-        let
-          version = self.shortRev or self.dirtyShortRev or "dev";
-        in
-        {
-          default = pkgs.buildGoModule {
+        buildGoModule {
           pname = "snitch";
           inherit version;
           src = self;
           vendorHash = "sha256-fX3wOqeOgjH7AuWGxPQxJ+wbhp240CW8tiF4rVUUDzk=";
-            env.CGO_ENABLED = 0;
+          # darwin requires cgo for libproc, linux uses pure go with /proc
+          env.CGO_ENABLED = if isDarwin then "1" else "0";
+          env.GOTOOLCHAIN = "local";
+          # darwin: use macOS 15 SDK for SecTrustCopyCertificateChain (Go 1.25 crypto/x509)
+          buildInputs = pkgs.lib.optionals isDarwin [ pkgs.apple-sdk_15 ];
           ldflags = [
-              "-s" "-w"
+            "-s"
+            "-w"
             "-X snitch/cmd.Version=${version}"
-              "-X snitch/cmd.Commit=${version}"
+            "-X snitch/cmd.Commit=${rev}"
             "-X snitch/cmd.Date=${self.lastModifiedDate or "unknown"}"
           ];
-            meta = with pkgs.lib; {
+          meta = {
             description = "a friendlier ss/netstat for humans";
             homepage = "https://github.com/karol-broda/snitch";
-              license = licenses.mit;
-              platforms = platforms.linux;
+            license = pkgs.lib.licenses.mit;
+            platforms = pkgs.lib.platforms.linux ++ pkgs.lib.platforms.darwin;
             mainProgram = "snitch";
           };
         };
+    in
+    {
+      packages = eachSystem (system:
+        let pkgs = pkgsFor system; in
+        {
+          default = mkSnitch pkgs;
+          snitch = mkSnitch pkgs;
         }
       );
 
-      devShells = forAllSystems (system:
+      devShells = eachSystem (system:
         let
-          pkgs = import nixpkgs {
-            inherit system;
-            overlays = [ goOverlay ];
-          };
+          pkgs = pkgsFor system;
+          go = mkGo125 pkgs;
         in
         {
           default = pkgs.mkShell {
-            packages = [ pkgs.go_1_25 pkgs.git pkgs.vhs ];
-            GOTOOLCHAIN = "local";
+            packages = [ go pkgs.git pkgs.vhs ];
+            env.GOTOOLCHAIN = "local";
             shellHook = ''
               echo "go toolchain: $(go version)"
             '';
           };
         }
       );
+
+      overlays.default = final: _prev: {
+        snitch = mkSnitch final;
+      };
     };
 }

go.mod

@@ -1,23 +1,26 @@
-module snitch
+module github.com/karol-broda/snitch
 
-go 1.24.0
+go 1.25.0
 
 require (
 	github.com/charmbracelet/bubbletea v1.3.6
+	github.com/charmbracelet/lipgloss v1.1.0
+	github.com/charmbracelet/x/exp/teatest v0.0.0-20251215102626-e0db08df7383
 	github.com/fatih/color v1.18.0
+	github.com/mattn/go-runewidth v0.0.16
 	github.com/spf13/cobra v1.9.1
+	github.com/spf13/viper v1.19.0
 	github.com/tidwall/pretty v1.2.1
+	golang.org/x/term v0.38.0
 )
 
 require (
 	github.com/aymanbagabas/go-osc52/v2 v2.0.1 // indirect
 	github.com/aymanbagabas/go-udiff v0.3.1 // indirect
 	github.com/charmbracelet/colorprofile v0.3.2 // indirect
-	github.com/charmbracelet/lipgloss v1.1.0 // indirect
 	github.com/charmbracelet/x/ansi v0.10.1 // indirect
 	github.com/charmbracelet/x/cellbuf v0.0.13-0.20250311204145-2c3ea96c31dd // indirect
 	github.com/charmbracelet/x/exp/golden v0.0.0-20240806155701-69247e0abc2a // indirect
-	github.com/charmbracelet/x/exp/teatest v0.0.0-20251215102626-e0db08df7383 // indirect
 	github.com/charmbracelet/x/term v0.2.1 // indirect
 	github.com/erikgeiser/coninput v0.0.0-20211004153227-1c3628e74d0f // indirect
 	github.com/fsnotify/fsnotify v1.7.0 // indirect
@@ -28,7 +31,6 @@ require (
 	github.com/mattn/go-colorable v0.1.13 // indirect
 	github.com/mattn/go-isatty v0.0.20 // indirect
 	github.com/mattn/go-localereader v0.0.1 // indirect
-	github.com/mattn/go-runewidth v0.0.16 // indirect
 	github.com/mitchellh/mapstructure v1.5.0 // indirect
 	github.com/muesli/ansi v0.0.0-20230316100256-276c6243b2f6 // indirect
 	github.com/muesli/cancelreader v0.2.2 // indirect
@@ -41,7 +43,6 @@ require (
 	github.com/spf13/afero v1.11.0 // indirect
 	github.com/spf13/cast v1.6.0 // indirect
 	github.com/spf13/pflag v1.0.6 // indirect
-	github.com/spf13/viper v1.19.0 // indirect
 	github.com/subosito/gotenv v1.6.0 // indirect
 	github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e // indirect
 	go.uber.org/atomic v1.9.0 // indirect
@@ -49,7 +50,6 @@ require (
 	golang.org/x/exp v0.0.0-20231006140011-7918f672742d // indirect
 	golang.org/x/sync v0.16.0 // indirect
 	golang.org/x/sys v0.39.0 // indirect
-	golang.org/x/term v0.38.0 // indirect
 	golang.org/x/text v0.28.0 // indirect
 	gopkg.in/ini.v1 v1.67.0 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect

go.sum

@@ -4,14 +4,10 @@ github.com/aymanbagabas/go-udiff v0.3.1 h1:LV+qyBQ2pqe0u42ZsUEtPiCaUoqgA9gYRDs3v
 github.com/aymanbagabas/go-udiff v0.3.1/go.mod h1:G0fsKmG+P6ylD0r6N/KgQD/nWzgfnl8ZBcNLgcbrw8E=
 github.com/charmbracelet/bubbletea v1.3.6 h1:VkHIxPJQeDt0aFJIsVxw8BQdh/F/L2KKZGsK6et5taU=
 github.com/charmbracelet/bubbletea v1.3.6/go.mod h1:oQD9VCRQFF8KplacJLo28/jofOI2ToOfGYeFgBBxHOc=
-github.com/charmbracelet/colorprofile v0.2.3-0.20250311203215-f60798e515dc h1:4pZI35227imm7yK2bGPcfpFEmuY1gc2YSTShr4iJBfs=
-github.com/charmbracelet/colorprofile v0.2.3-0.20250311203215-f60798e515dc/go.mod h1:X4/0JoqgTIPSFcRA/P6INZzIuyqdFY5rm8tb41s9okk=
 github.com/charmbracelet/colorprofile v0.3.2 h1:9J27WdztfJQVAQKX2WOlSSRB+5gaKqqITmrvb1uTIiI=
 github.com/charmbracelet/colorprofile v0.3.2/go.mod h1:mTD5XzNeWHj8oqHb+S1bssQb7vIHbepiebQ2kPKVKbI=
 github.com/charmbracelet/lipgloss v1.1.0 h1:vYXsiLHVkK7fp74RkV7b2kq9+zDLoEU4MZoFqR/noCY=
 github.com/charmbracelet/lipgloss v1.1.0/go.mod h1:/6Q8FR2o+kj8rz4Dq0zQc3vYf7X+B0binUUBwA0aL30=
-github.com/charmbracelet/x/ansi v0.9.3 h1:BXt5DHS/MKF+LjuK4huWrC6NCvHtexww7dMayh6GXd0=
-github.com/charmbracelet/x/ansi v0.9.3/go.mod h1:3RQDQ6lDnROptfpWuUVIUG64bD2g2BgntdxH0Ya5TeE=
 github.com/charmbracelet/x/ansi v0.10.1 h1:rL3Koar5XvX0pHGfovN03f5cxLbCF2YvLeyz7D2jVDQ=
 github.com/charmbracelet/x/ansi v0.10.1/go.mod h1:3RQDQ6lDnROptfpWuUVIUG64bD2g2BgntdxH0Ya5TeE=
 github.com/charmbracelet/x/cellbuf v0.0.13-0.20250311204145-2c3ea96c31dd h1:vy0GVL4jeHEwG5YOXDmi86oYw2yuYUGqz6a8sLwg0X8=
@@ -25,16 +21,26 @@ github.com/charmbracelet/x/term v0.2.1/go.mod h1:oQ4enTYFV7QN4m0i9mzHrViD7TQKvNE
 github.com/cpuguy83/go-md2man/v2 v2.0.6/go.mod h1:oOW0eioCTA6cOiMLiUPZOpcVxMig6NIQQ7OS05n1F4g=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1VwoXQT9A3Wy9MM3WgvqSxFWenqJduM=
+github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/erikgeiser/coninput v0.0.0-20211004153227-1c3628e74d0f h1:Y/CXytFA4m6baUTXGLOoWe4PQhGxaX0KpnayAqC48p4=
 github.com/erikgeiser/coninput v0.0.0-20211004153227-1c3628e74d0f/go.mod h1:vw97MGsxSvLiUE2X8qFplwetxpGLQrlU1Q9AUEIzCaM=
 github.com/fatih/color v1.18.0 h1:S8gINlzdQ840/4pfAwic/ZE0djQEH3wM94VfqLTZcOM=
 github.com/fatih/color v1.18.0/go.mod h1:4FelSpRwEGDpQ12mAdzqdOukCy4u8WUtOY6lkT/6HfU=
+github.com/frankban/quicktest v1.14.6 h1:7Xjx+VpznH+oBnejlPUj8oUpdxnVs4f8XU8WnHkI4W8=
+github.com/frankban/quicktest v1.14.6/go.mod h1:4ptaffx2x8+WTWXmUCuVU6aPUX1/Mz7zb5vbUoiM6w0=
 github.com/fsnotify/fsnotify v1.7.0 h1:8JEhPFa5W2WU7YfeZzPNqzMP6Lwt7L2715Ggo0nosvA=
 github.com/fsnotify/fsnotify v1.7.0/go.mod h1:40Bi/Hjc2AVfZrqy+aj+yEI+/bRxZnMJyTJwOpGvigM=
+github.com/google/go-cmp v0.5.9 h1:O2Tfq5qg4qc4AmwVlvv0oLiVAGB7enBSJ2x2DqQFi38=
+github.com/google/go-cmp v0.5.9/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
 github.com/hashicorp/hcl v1.0.0 h1:0Anlzjpi4vEasTeNFn2mLJgTSwt0+6sfsiTG8qcWGx4=
 github.com/hashicorp/hcl v1.0.0/go.mod h1:E5yfLk+7swimpb2L/Alb/PJmXilQ/rhwaUYs4T20WEQ=
 github.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2s0bqwp9tc8=
 github.com/inconshreveable/mousetrap v1.1.0/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLfsEA9PFc4w1p2J65bw=
+github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
+github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
+github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
+github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
 github.com/lucasb-eyer/go-colorful v1.2.0 h1:1nnpGOrhyZZuNyfu1QjKiUICQ74+3FNCN69Aj6K7nkY=
 github.com/lucasb-eyer/go-colorful v1.2.0/go.mod h1:R4dSotOR9KMtayYi1e77YzuveK+i7ruzyGqttikkLy0=
 github.com/magiconair/properties v1.8.7 h1:IeQXZAiQcpL9mgcAe1Nu6cX9LLw6ExEHKjN0VQdvPDY=
@@ -59,9 +65,13 @@ github.com/muesli/termenv v0.16.0/go.mod h1:ZRfOIKPFDYQoDFF4Olj7/QJbW60Ol/kL1pU3
 github.com/pelletier/go-toml/v2 v2.2.2 h1:aYUidT7k73Pcl9nb2gScu7NSrKCSHIDE89b3+6Wq+LM=
 github.com/pelletier/go-toml/v2 v2.2.2/go.mod h1:1t835xjRzz80PqgE6HHgN2JOsmgYu/h4qDAS4n929Rs=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRIccs7FGNTlIRMkT8wgtp5eCXdBlqhYGL6U=
+github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
 github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ=
 github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
+github.com/rogpeppe/go-internal v1.9.0 h1:73kH8U+JUqXU8lRuOHeVHaa/SZPifC7BkcraZVejAe8=
+github.com/rogpeppe/go-internal v1.9.0/go.mod h1:WtVeX8xhTBvf0smdhujwtBcq4Qrzq/fJaraNFVN+nFs=
 github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
 github.com/sagikazarmark/locafero v0.4.0 h1:HApY1R9zGo4DBgr7dqsTH/JJxLTTsOt7u6keLGt6kNQ=
 github.com/sagikazarmark/locafero v0.4.0/go.mod h1:Pe1W6UlPYUk/+wc/6KFhbORCfqzgYEpgQ3O5fPuL3H4=
@@ -87,6 +97,7 @@ github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UV
 github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
 github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
 github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
+github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg=
 github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
 github.com/subosito/gotenv v1.6.0 h1:9NlTDc1FTs4qu0DDq7AEtTPNw6SVm7uBMsUCUjABIf8=
 github.com/subosito/gotenv v1.6.0/go.mod h1:Dk4QP5c2W3ibzajGcXpNraDfq2IrhjMIvMSWPKKo0FU=
@@ -98,28 +109,22 @@ go.uber.org/atomic v1.9.0 h1:ECmE8Bn/WFTYwEW/bpKD3M8VtR/zQVbavAoalC1PYyE=
 go.uber.org/atomic v1.9.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc=
 go.uber.org/multierr v1.9.0 h1:7fIwc/ZtS0q++VgcfqFDxSBZVv/Xo49/SYnDFupUwlI=
 go.uber.org/multierr v1.9.0/go.mod h1:X2jQV1h+kxSjClGpnseKVIxpmcjrj7MNnI0bnlfKTVQ=
-golang.org/x/exp v0.0.0-20230905200255-921286631fa9 h1:GoHiUyI/Tp2nVkLI2mCxVkOjsbSXD66ic0XW0js0R9g=
-golang.org/x/exp v0.0.0-20230905200255-921286631fa9/go.mod h1:S2oDrQGGwySpoQPVqRShND87VCbxmc6bL1Yd2oYrm6k=
 golang.org/x/exp v0.0.0-20231006140011-7918f672742d h1:jtJma62tbqLibJ5sFQz8bKtEM8rJBtfilJ2qTU199MI=
 golang.org/x/exp v0.0.0-20231006140011-7918f672742d/go.mod h1:ldy0pHrwJyGW56pPQzzkH36rKxoZW1tw7ZJpeKx+hdo=
-golang.org/x/sync v0.15.0 h1:KWH3jNZsfyT6xfAfKiz6MRNmd46ByHDYaZ7KSkCtdW8=
-golang.org/x/sync v0.15.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA=
 golang.org/x/sync v0.16.0 h1:ycBJEhp9p4vXvUZNszeOq0kGTPghopOL8q0fq3vstxw=
 golang.org/x/sync v0.16.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA=
 golang.org/x/sys v0.0.0-20210809222454-d867a43fc93e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.33.0 h1:q3i8TbbEz+JRD9ywIRlyRAQbM0qF7hu24q3teo2hbuw=
-golang.org/x/sys v0.33.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
 golang.org/x/sys v0.39.0 h1:CvCKL8MeisomCi6qNZ+wbb0DN9E5AATixKsvNtMoMFk=
 golang.org/x/sys v0.39.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=
 golang.org/x/term v0.38.0 h1:PQ5pkm/rLO6HnxFR7N2lJHOZX6Kez5Y1gDSJla6jo7Q=
 golang.org/x/term v0.38.0/go.mod h1:bSEAKrOT1W+VSu9TSCMtoGEOUcKxOKgl3LE5QEF/xVg=
-golang.org/x/text v0.14.0 h1:ScX5w1eTa3QqT8oi6+ziP7dTV1S2+ALU0bI+0zXKWiQ=
-golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
 golang.org/x/text v0.28.0 h1:rhazDwis8INMIwQ4tpjLDzUhx6RlXqZNPEM0huQojng=
 golang.org/x/text v0.28.0/go.mod h1:U8nCwOR8jO/marOQ0QbDiOngZVEBB7MAiitBuMjXiNU=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15 h1:YR8cESwS4TdDjEe65xsg0ogRM/Nc3DYOhEAlW+xobZo=
+gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/ini.v1 v1.67.0 h1:Dgnx+6+nfE+IfzjUEISNeydPJh9AXNNsWbGP9KzCsOA=
 gopkg.in/ini.v1 v1.67.0/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k=
 gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

install.sh

@@ -0,0 +1,113 @@
+#!/bin/sh
+set -e
+
+REPO="karol-broda/snitch"
+BINARY_NAME="snitch"
+
+# allow override via environment
+INSTALL_DIR="${INSTALL_DIR:-}"
+KEEP_QUARANTINE="${KEEP_QUARANTINE:-}"
+
+detect_install_dir() {
+    if [ -n "$INSTALL_DIR" ]; then
+        echo "$INSTALL_DIR"
+        return
+    fi
+
+    # prefer user-local directory if it exists and is in PATH
+    if [ -d "$HOME/.local/bin" ] && echo "$PATH" | grep -q "$HOME/.local/bin"; then
+        echo "$HOME/.local/bin"
+        return
+    fi
+
+    # fallback to /usr/local/bin
+    echo "/usr/local/bin"
+}
+
+detect_os() {
+    os=$(uname -s | tr '[:upper:]' '[:lower:]')
+    case "$os" in
+        darwin) echo "darwin" ;;
+        linux) echo "linux" ;;
+        *)
+            echo "error: unsupported operating system: $os" >&2
+            exit 1
+            ;;
+    esac
+}
+
+detect_arch() {
+    arch=$(uname -m)
+    case "$arch" in
+        x86_64|amd64) echo "amd64" ;;
+        aarch64|arm64) echo "arm64" ;;
+        armv7l) echo "armv7" ;;
+        *)
+            echo "error: unsupported architecture: $arch" >&2
+            exit 1
+            ;;
+    esac
+}
+
+fetch_latest_version() {
+    version=$(curl -sL "https://api.github.com/repos/${REPO}/releases/latest" | grep '"tag_name"' | head -1 | cut -d'"' -f4)
+    if [ -z "$version" ]; then
+        echo "error: failed to fetch latest version" >&2
+        exit 1
+    fi
+    echo "$version"
+}
+
+main() {
+    os=$(detect_os)
+    arch=$(detect_arch)
+    install_dir=$(detect_install_dir)
+    version=$(fetch_latest_version)
+    version_no_v="${version#v}"
+
+    archive_name="${BINARY_NAME}_${version_no_v}_${os}_${arch}.tar.gz"
+    download_url="https://github.com/${REPO}/releases/download/${version}/${archive_name}"
+
+    echo "installing ${BINARY_NAME} ${version} for ${os}/${arch}..."
+
+    tmp_dir=$(mktemp -d)
+    trap 'rm -rf "$tmp_dir"' EXIT
+
+    echo "downloading ${download_url}..."
+    if ! curl -sL --fail "$download_url" -o "${tmp_dir}/${archive_name}"; then
+        echo "error: failed to download ${download_url}" >&2
+        exit 1
+    fi
+
+    echo "extracting..."
+    tar -xzf "${tmp_dir}/${archive_name}" -C "$tmp_dir"
+
+    if [ ! -f "${tmp_dir}/${BINARY_NAME}" ]; then
+        echo "error: binary not found in archive" >&2
+        exit 1
+    fi
+
+    # remove macos quarantine attribute unless disabled
+    if [ "$os" = "darwin" ] && [ -z "$KEEP_QUARANTINE" ]; then
+        if xattr -d com.apple.quarantine "${tmp_dir}/${BINARY_NAME}" 2>/dev/null; then
+            echo "warning: removed macOS quarantine attribute from binary"
+        fi
+    fi
+
+    # install binary
+    if [ -w "$install_dir" ]; then
+        mv "${tmp_dir}/${BINARY_NAME}" "${install_dir}/${BINARY_NAME}"
+    else
+        echo "elevated permissions required to install to ${install_dir}"
+        sudo mv "${tmp_dir}/${BINARY_NAME}" "${install_dir}/${BINARY_NAME}"
+    fi
+
+    chmod +x "${install_dir}/${BINARY_NAME}"
+
+    echo "installed ${BINARY_NAME} to ${install_dir}/${BINARY_NAME}"
+    echo ""
+    echo "run '${BINARY_NAME} --help' to get started"
+}
+
+main
+

internal/collector/collector_linux.go

@@ -11,21 +11,78 @@ import (
 	"path/filepath"
 	"strconv"
 	"strings"
+	"sync"
+	"sync/atomic"
 	"time"
+
+	"github.com/karol-broda/snitch/internal/errutil"
 )
 
+// set SNITCH_DEBUG_TIMING=1 to enable timing diagnostics
+var debugTiming = os.Getenv("SNITCH_DEBUG_TIMING") != ""
+
+func logTiming(label string, start time.Time, extra ...string) {
+	if !debugTiming {
+		return
+	}
+	elapsed := time.Since(start)
+	if len(extra) > 0 {
+		fmt.Fprintf(os.Stderr, "[timing] %s: %v (%s)\n", label, elapsed, extra[0])
+	} else {
+		fmt.Fprintf(os.Stderr, "[timing] %s: %v\n", label, elapsed)
+	}
+}
+
+// userCache caches uid to username mappings to avoid repeated lookups
+var userCache = struct {
+	sync.RWMutex
+	m map[int]string
+}{m: make(map[int]string)}
+
+func lookupUsername(uid int) string {
+	userCache.RLock()
+	if username, exists := userCache.m[uid]; exists {
+		userCache.RUnlock()
+		return username
+	}
+	userCache.RUnlock()
+
+	start := time.Now()
+	username := strconv.Itoa(uid)
+	u, err := user.LookupId(strconv.Itoa(uid))
+	if err == nil && u != nil {
+		username = u.Username
+	}
+	elapsed := time.Since(start)
+	if debugTiming && elapsed > 10*time.Millisecond {
+		fmt.Fprintf(os.Stderr, "[timing] user.LookupId(%d) slow: %v\n", uid, elapsed)
+	}
+
+	userCache.Lock()
+	userCache.m[uid] = username
+	userCache.Unlock()
+
+	return username
+}
+
 // DefaultCollector implements the Collector interface using /proc filesystem
 type DefaultCollector struct{}
 
 // GetConnections fetches all network connections by parsing /proc files
 func (dc *DefaultCollector) GetConnections() ([]Connection, error) {
+	totalStart := time.Now()
+	defer func() { logTiming("GetConnections total", totalStart) }()
+
+	inodeStart := time.Now()
 	inodeMap, err := buildInodeToProcessMap()
+	logTiming("buildInodeToProcessMap", inodeStart, fmt.Sprintf("%d inodes", len(inodeMap)))
 	if err != nil {
 		return nil, fmt.Errorf("failed to build inode map: %w", err)
 	}
 
 	var connections []Connection
 
+	parseStart := time.Now()
 	tcpConns, err := parseProcNet("/proc/net/tcp", "tcp", 4, inodeMap)
 	if err == nil {
 		connections = append(connections, tcpConns...)
@@ -45,6 +102,7 @@ func (dc *DefaultCollector) GetConnections() ([]Connection, error) {
 	if err == nil {
 		connections = append(connections, udpConns6...)
 	}
+	logTiming("parseProcNet (all)", parseStart, fmt.Sprintf("%d connections", len(connections)))
 
 	return connections, nil
 }
@@ -71,42 +129,97 @@ type processInfo struct {
 	user    string
 }
 
-func buildInodeToProcessMap() (map[int64]*processInfo, error) {
-	inodeMap := make(map[int64]*processInfo)
+type inodeEntry struct {
+	inode int64
+	info  *processInfo
+}
 
+func buildInodeToProcessMap() (map[int64]*processInfo, error) {
+	readDirStart := time.Now()
 	procDir, err := os.Open("/proc")
 	if err != nil {
 		return nil, err
 	}
-	defer procDir.Close()
+	defer errutil.Close(procDir)
 
 	entries, err := procDir.Readdir(-1)
 	if err != nil {
 		return nil, err
 	}
 
+	// collect pids first
+	pids := make([]int, 0, len(entries))
 	for _, entry := range entries {
 		if !entry.IsDir() {
 			continue
 		}
-
-		pidStr := entry.Name()
-		pid, err := strconv.Atoi(pidStr)
+		pid, err := strconv.Atoi(entry.Name())
 		if err != nil {
 			continue
 		}
+		pids = append(pids, pid)
+	}
+	logTiming("  readdir /proc", readDirStart, fmt.Sprintf("%d pids", len(pids)))
+
+	// process pids in parallel with limited concurrency
+	scanStart := time.Now()
+	const numWorkers = 8
+	pidChan := make(chan int, len(pids))
+	resultChan := make(chan []inodeEntry, len(pids))
+
+	var totalFDs atomic.Int64
+	var wg sync.WaitGroup
+	for i := 0; i < numWorkers; i++ {
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			for pid := range pidChan {
+				entries := scanProcessSockets(pid)
+				if len(entries) > 0 {
+					totalFDs.Add(int64(len(entries)))
+					resultChan <- entries
+				}
+			}
+		}()
+	}
+
+	for _, pid := range pids {
+		pidChan <- pid
+	}
+	close(pidChan)
+
+	go func() {
+		wg.Wait()
+		close(resultChan)
+	}()
+
+	inodeMap := make(map[int64]*processInfo)
+	for entries := range resultChan {
+		for _, e := range entries {
+			inodeMap[e.inode] = e.info
+		}
+	}
+	logTiming("  scan all processes", scanStart, fmt.Sprintf("%d socket fds scanned", totalFDs.Load()))
+
+	return inodeMap, nil
+}
+
+func scanProcessSockets(pid int) []inodeEntry {
+	start := time.Now()
 
 	procInfo, err := getProcessInfo(pid)
 	if err != nil {
-			continue
+		return nil
 	}
 
+	pidStr := strconv.Itoa(pid)
 	fdDir := filepath.Join("/proc", pidStr, "fd")
 	fdEntries, err := os.ReadDir(fdDir)
 	if err != nil {
-			continue
+		return nil
 	}
 
+	var results []inodeEntry
 	for _, fdEntry := range fdEntries {
 		fdPath := filepath.Join(fdDir, fdEntry.Name())
 		link, err := os.Readlink(fdPath)
@@ -120,12 +233,17 @@ func buildInodeToProcessMap() (map[int64]*processInfo, error) {
 			if err != nil {
 				continue
 			}
-				inodeMap[inode] = procInfo
-			}
+			results = append(results, inodeEntry{inode: inode, info: procInfo})
 		}
 	}
 
-	return inodeMap, nil
+	elapsed := time.Since(start)
+	if debugTiming && elapsed > 20*time.Millisecond {
+		fmt.Fprintf(os.Stderr, "[timing] slow process scan: pid=%d (%s) fds=%d time=%v\n",
+			pid, procInfo.command, len(fdEntries), elapsed)
+	}
+
+	return results
 }
 
 func getProcessInfo(pid int) (*processInfo, error) {
@@ -162,7 +280,7 @@ func getProcessInfo(pid int) (*processInfo, error) {
 	if err != nil {
 		return info, nil
 	}
-	defer statusFile.Close()
+	defer errutil.Close(statusFile)
 
 	scanner := bufio.NewScanner(statusFile)
 	for scanner.Scan() {
@@ -173,12 +291,7 @@ func getProcessInfo(pid int) (*processInfo, error) {
 				uid, err := strconv.Atoi(fields[1])
 				if err == nil {
 					info.uid = uid
-					u, err := user.LookupId(strconv.Itoa(uid))
-					if err == nil {
-						info.user = u.Username
-					} else {
-						info.user = strconv.Itoa(uid)
-					}
+					info.user = lookupUsername(uid)
 				}
 			}
 			break
@@ -193,7 +306,7 @@ func parseProcNet(path, proto string, ipVersion int, inodeMap map[int64]*process
 	if err != nil {
 		return nil, err
 	}
-	defer file.Close()
+	defer errutil.Close(file)
 
 	var connections []Connection
 	scanner := bufio.NewScanner(file)
@@ -362,7 +475,7 @@ func GetUnixSockets() ([]Connection, error) {
 	if err != nil {
 		return connections, nil
 	}
-	defer file.Close()
+	defer errutil.Close(file)
 
 	scanner := bufio.NewScanner(file)
 	scanner.Scan()

internal/collector/collector_test.go

@@ -1,7 +1,10 @@
+//go:build linux
+
 package collector
 
 import (
 	"testing"
+	"time"
 )
 
 func TestGetConnections(t *testing.T) {
@@ -14,3 +17,101 @@ func TestGetConnections(t *testing.T) {
 	// connections are dynamic, so just verify function succeeded
 	t.Logf("Successfully got %d connections", len(conns))
 }
+
+func TestGetConnectionsPerformance(t *testing.T) {
+	// measures performance to catch regressions
+	// run with: go test -v -run TestGetConnectionsPerformance
+
+	const maxDuration = 500 * time.Millisecond
+	const iterations = 5
+
+	// warm up caches first
+	_, err := GetConnections()
+	if err != nil {
+		t.Fatalf("warmup failed: %v", err)
+	}
+
+	var total time.Duration
+	var maxSeen time.Duration
+
+	for i := 0; i < iterations; i++ {
+		start := time.Now()
+		conns, err := GetConnections()
+		elapsed := time.Since(start)
+
+		if err != nil {
+			t.Fatalf("iteration %d failed: %v", i, err)
+		}
+
+		total += elapsed
+		if elapsed > maxSeen {
+			maxSeen = elapsed
+		}
+
+		t.Logf("iteration %d: %v (%d connections)", i+1, elapsed, len(conns))
+	}
+
+	avg := total / time.Duration(iterations)
+	t.Logf("average: %v, max: %v", avg, maxSeen)
+
+	if maxSeen > maxDuration {
+		t.Errorf("slowest iteration took %v, expected < %v", maxSeen, maxDuration)
+	}
+}
+
+func TestGetConnectionsColdCache(t *testing.T) {
+	// tests performance with cold user cache
+	// this simulates first run or after cache invalidation
+
+	const maxDuration = 2 * time.Second
+
+	clearUserCache()
+
+	start := time.Now()
+	conns, err := GetConnections()
+	elapsed := time.Since(start)
+
+	if err != nil {
+		t.Fatalf("GetConnections() failed: %v", err)
+	}
+
+	t.Logf("cold cache: %v (%d connections, %d cached users after)",
+		elapsed, len(conns), userCacheSize())
+
+	if elapsed > maxDuration {
+		t.Errorf("cold cache took %v, expected < %v", elapsed, maxDuration)
+	}
+}
+
+func BenchmarkGetConnections(b *testing.B) {
+	// warm cache benchmark - measures typical runtime
+	// run with: go test -bench=BenchmarkGetConnections -benchtime=5s
+
+	// warm up
+	_, _ = GetConnections()
+
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		_, _ = GetConnections()
+	}
+}
+
+func BenchmarkGetConnectionsColdCache(b *testing.B) {
+	// cold cache benchmark - measures worst-case with cache cleared each iteration
+	// run with: go test -bench=BenchmarkGetConnectionsColdCache -benchtime=10s
+
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		clearUserCache()
+		_, _ = GetConnections()
+	}
+}
+
+func BenchmarkBuildInodeMap(b *testing.B) {
+	// benchmarks just the inode map building (most expensive part)
+
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		_, _ = buildInodeToProcessMap()
+	}
+}

internal/collector/collector_test_helpers_linux.go

@@ -0,0 +1,18 @@
+//go:build linux
+
+package collector
+
+// clearUserCache clears the user lookup cache for testing
+func clearUserCache() {
+	userCache.Lock()
+	userCache.m = make(map[int]string)
+	userCache.Unlock()
+}
+
+// userCacheSize returns the number of cached user entries
+func userCacheSize() int {
+	userCache.RLock()
+	defer userCache.RUnlock()
+	return len(userCache.m)
+}
+

internal/color/color_test.go

@@ -5,6 +5,8 @@ import (
 	"testing"
 
 	"github.com/fatih/color"
+
+	"github.com/karol-broda/snitch/internal/errutil"
 )
 
 func TestInit(t *testing.T) {
@@ -29,8 +31,8 @@ func TestInit(t *testing.T) {
 			origTerm := os.Getenv("TERM")
 
 			// Set test env vars
-			os.Setenv("NO_COLOR", tc.noColor)
-			os.Setenv("TERM", tc.term)
+			errutil.Setenv("NO_COLOR", tc.noColor)
+			errutil.Setenv("TERM", tc.term)
 
 			Init(tc.mode)
 
@@ -39,8 +41,8 @@ func TestInit(t *testing.T) {
 			}
 
 			// Restore original env vars
-			os.Setenv("NO_COLOR", origNoColor)
-			os.Setenv("TERM", origTerm)
+			errutil.Setenv("NO_COLOR", origNoColor)
+			errutil.Setenv("TERM", origTerm)
 		})
 	}
 }

internal/config/config.go

@@ -4,8 +4,10 @@ import (
 	"fmt"
 	"os"
 	"path/filepath"
+	"strings"
 	"time"
 
+	"github.com/karol-broda/snitch/internal/theme"
 	"github.com/spf13/viper"
 )
 
@@ -23,6 +25,7 @@ type DefaultConfig struct {
 	Units        string   `mapstructure:"units"`
 	Color        string   `mapstructure:"color"`
 	Resolve      bool     `mapstructure:"resolve"`
+	DNSCache     bool     `mapstructure:"dns_cache"`
 	IPv4         bool     `mapstructure:"ipv4"`
 	IPv6         bool     `mapstructure:"ipv6"`
 	NoHeaders    bool     `mapstructure:"no_headers"`
@@ -55,6 +58,7 @@ func Load() (*Config, error) {
 	// environment variable bindings for readme-documented variables
 	_ = v.BindEnv("config", "SNITCH_CONFIG")
 	_ = v.BindEnv("defaults.resolve", "SNITCH_RESOLVE")
+	_ = v.BindEnv("defaults.dns_cache", "SNITCH_DNS_CACHE")
 	_ = v.BindEnv("defaults.theme", "SNITCH_THEME")
 	_ = v.BindEnv("defaults.color", "SNITCH_NO_COLOR")
 	
@@ -88,14 +92,14 @@ func Load() (*Config, error) {
 }
 
 func setDefaults(v *viper.Viper) {
-	// Set default values matching the README specification
 	v.SetDefault("defaults.interval", "1s")
 	v.SetDefault("defaults.numeric", false)
 	v.SetDefault("defaults.fields", []string{"pid", "process", "user", "proto", "state", "laddr", "lport", "raddr", "rport"})
-	v.SetDefault("defaults.theme", "auto")
+	v.SetDefault("defaults.theme", "ansi")
 	v.SetDefault("defaults.units", "auto")
 	v.SetDefault("defaults.color", "auto")
 	v.SetDefault("defaults.resolve", true)
+	v.SetDefault("defaults.dns_cache", true)
 	v.SetDefault("defaults.ipv4", false)
 	v.SetDefault("defaults.ipv6", false)
 	v.SetDefault("defaults.no_headers", false)
@@ -114,6 +118,11 @@ func handleSpecialEnvVars(v *viper.Viper) {
 		v.Set("defaults.resolve", false)
 		v.Set("defaults.numeric", true)
 	}
+
+	// Handle SNITCH_DNS_CACHE - if set to "0", disable dns caching
+	if os.Getenv("SNITCH_DNS_CACHE") == "0" {
+		v.Set("defaults.dns_cache", false)
+	}
 }
 
 // Get returns the global configuration, loading it if necessary
@@ -121,16 +130,16 @@ func Get() *Config {
 	if globalConfig == nil {
 		config, err := Load()
 		if err != nil {
-			// Return default config on error
 			return &Config{
 				Defaults: DefaultConfig{
 					Interval:     "1s",
 					Numeric:      false,
 					Fields:       []string{"pid", "process", "user", "proto", "state", "laddr", "lport", "raddr", "rport"},
-					Theme:        "auto",
+					Theme:        "ansi",
 					Units:        "auto",
 					Color:        "auto",
 					Resolve:      true,
+					DNSCache:     true,
 					IPv4:         false,
 					IPv6:         false,
 					NoHeaders:    false,
@@ -154,7 +163,9 @@ func (c *Config) GetInterval() time.Duration {
 
 // CreateExampleConfig creates an example configuration file
 func CreateExampleConfig(path string) error {
-	exampleConfig := `# snitch configuration file
+	themeList := strings.Join(theme.ListThemes(), ", ")
+
+	exampleConfig := fmt.Sprintf(`# snitch configuration file
 # See https://github.com/you/snitch for full documentation
 
 [defaults]
@@ -167,8 +178,9 @@ numeric = false
 # Default fields to display (comma-separated list)
 fields = ["pid", "process", "user", "proto", "state", "laddr", "lport", "raddr", "rport"]
 
-# Default theme for TUI (dark, light, mono, auto)
-theme = "auto"
+# Default theme for TUI (ansi inherits terminal colors)
+# Available: %s
+theme = "%s"
 
 # Default units for byte display (auto, si, iec)
 units = "auto"
@@ -187,7 +199,7 @@ ipv6 = false
 no_headers = false
 output_format = "table"
 sort_by = ""
-`
+`, themeList, theme.DefaultTheme)
 
 	// Ensure directory exists
 	if err := os.MkdirAll(filepath.Dir(path), 0755); err != nil {

internal/errutil/errutil.go

@@ -0,0 +1,65 @@
+package errutil
+
+import (
+	"io"
+	"os"
+
+	"github.com/fatih/color"
+)
+
+func Ignore[T any](val T, _ error) T {
+	return val
+}
+
+func IgnoreErr(_ error) {}
+
+func Close(c io.Closer) {
+	if c != nil {
+		_ = c.Close()
+	}
+}
+
+// color.Color wrappers - these discard the (int, error) return values
+
+func Print(c *color.Color, a ...any) {
+	_, _ = c.Print(a...)
+}
+
+func Println(c *color.Color, a ...any) {
+	_, _ = c.Println(a...)
+}
+
+func Printf(c *color.Color, format string, a ...any) {
+	_, _ = c.Printf(format, a...)
+}
+
+func Fprintf(c *color.Color, w io.Writer, format string, a ...any) {
+	_, _ = c.Fprintf(w, format, a...)
+}
+
+// os function wrappers for test cleanup where errors are non-critical
+
+func Setenv(key, value string) {
+	_ = os.Setenv(key, value)
+}
+
+func Unsetenv(key string) {
+	_ = os.Unsetenv(key)
+}
+
+func Remove(name string) {
+	_ = os.Remove(name)
+}
+
+func RemoveAll(path string) {
+	_ = os.RemoveAll(path)
+}
+
+// Flush calls Flush on a tabwriter and discards the error
+type Flusher interface {
+	Flush() error
+}
+
+func Flush(f Flusher) {
+	_ = f.Flush()
+}

internal/resolver/resolver.go

@@ -2,17 +2,22 @@ package resolver
 
 import (
 	"context"
+	"fmt"
 	"net"
+	"os"
 	"strconv"
 	"sync"
 	"time"
 )
 
+var debugTiming = os.Getenv("SNITCH_DEBUG_TIMING") != ""
+
 // Resolver handles DNS and service name resolution with caching and timeouts
 type Resolver struct {
 	timeout  time.Duration
 	cache    map[string]string
 	mutex    sync.RWMutex
+	noCache  bool
 }
 
 // New creates a new resolver with the specified timeout
@@ -20,45 +25,60 @@ func New(timeout time.Duration) *Resolver {
 	return &Resolver{
 		timeout: timeout,
 		cache:   make(map[string]string),
+		noCache: false,
 	}
 }
 
+// SetNoCache disables caching - each lookup will hit DNS directly
+func (r *Resolver) SetNoCache(noCache bool) {
+	r.noCache = noCache
+}
+
 // ResolveAddr resolves an IP address to a hostname, with caching
 func (r *Resolver) ResolveAddr(addr string) string {
-	// Check cache first
+	// check cache first (unless caching is disabled)
+	if !r.noCache {
 		r.mutex.RLock()
 		if cached, exists := r.cache[addr]; exists {
 			r.mutex.RUnlock()
 			return cached
 		}
 		r.mutex.RUnlock()
+	}
 
-	// Parse IP to validate it
+	// parse ip to validate it
 	ip := net.ParseIP(addr)
 	if ip == nil {
-		// Not a valid IP, return as-is
 		return addr
 	}
 
-	// Perform resolution with timeout
+	// perform resolution with timeout
+	start := time.Now()
 	ctx, cancel := context.WithTimeout(context.Background(), r.timeout)
 	defer cancel()
 
 	names, err := net.DefaultResolver.LookupAddr(ctx, addr)
 
-	resolved := addr // fallback to original address
+	resolved := addr
 	if err == nil && len(names) > 0 {
 		resolved = names[0]
-		// Remove trailing dot if present
+		// remove trailing dot if present
 		if len(resolved) > 0 && resolved[len(resolved)-1] == '.' {
 			resolved = resolved[:len(resolved)-1]
 		}
 	}
 
-	// Cache the result
+	elapsed := time.Since(start)
+	if debugTiming && elapsed > 50*time.Millisecond {
+		fmt.Fprintf(os.Stderr, "[timing] slow DNS lookup: %s -> %s (%v)\n", addr, resolved, elapsed)
+	}
+
+	// cache the result (unless caching is disabled)
+	if !r.noCache {
 		r.mutex.Lock()
 		r.cache[addr] = resolved
 		r.mutex.Unlock()
+	}
 
 	return resolved
 }
@@ -71,15 +91,17 @@ func (r *Resolver) ResolvePort(port int, proto string) string {
 
 	cacheKey := strconv.Itoa(port) + "/" + proto
 
-	// Check cache first
+	// check cache first (unless caching is disabled)
+	if !r.noCache {
 		r.mutex.RLock()
 		if cached, exists := r.cache[cacheKey]; exists {
 			r.mutex.RUnlock()
 			return cached
 		}
 		r.mutex.RUnlock()
+	}
 
-	// Perform resolution with timeout
+	// perform resolution with timeout
 	ctx, cancel := context.WithTimeout(context.Background(), r.timeout)
 	defer cancel()
 
@@ -87,16 +109,18 @@ func (r *Resolver) ResolvePort(port int, proto string) string {
 
 	resolved := strconv.Itoa(port) // fallback to port number
 	if err == nil && service != 0 {
-		// Try to get service name
+		// try to get service name
 		if serviceName := getServiceName(port, proto); serviceName != "" {
 			resolved = serviceName
 		}
 	}
 
-	// Cache the result
+	// cache the result (unless caching is disabled)
+	if !r.noCache {
 		r.mutex.Lock()
 		r.cache[cacheKey] = resolved
 		r.mutex.Unlock()
+	}
 
 	return resolved
 }
@@ -159,22 +183,38 @@ func getServiceName(port int, proto string) string {
 	return ""
 }
 
-// Global resolver instance
+// global resolver instance
 var globalResolver *Resolver
 
-// SetGlobalResolver sets the global resolver instance
-func SetGlobalResolver(timeout time.Duration) {
+// ResolverOptions configures the global resolver
+type ResolverOptions struct {
+	Timeout time.Duration
+	NoCache bool
+}
+
+// SetGlobalResolver sets the global resolver instance with options
+func SetGlobalResolver(opts ResolverOptions) {
+	timeout := opts.Timeout
+	if timeout == 0 {
+		timeout = 200 * time.Millisecond
+	}
 	globalResolver = New(timeout)
+	globalResolver.SetNoCache(opts.NoCache)
 }
 
 // GetGlobalResolver returns the global resolver instance
 func GetGlobalResolver() *Resolver {
 	if globalResolver == nil {
-		globalResolver = New(200 * time.Millisecond) // Default timeout
+		globalResolver = New(200 * time.Millisecond)
 	}
 	return globalResolver
 }
 
+// SetNoCache configures whether the global resolver bypasses cache
+func SetNoCache(noCache bool) {
+	GetGlobalResolver().SetNoCache(noCache)
+}
+
 // ResolveAddr is a convenience function using the global resolver
 func ResolveAddr(addr string) string {
 	return GetGlobalResolver().ResolveAddr(addr)
@@ -189,3 +229,48 @@ func ResolvePort(port int, proto string) string {
 func ResolveAddrPort(addr string, port int, proto string) (string, string) {
 	return GetGlobalResolver().ResolveAddrPort(addr, port, proto)
 }
+
+// ResolveAddrsParallel resolves multiple addresses concurrently and caches results.
+// This should be called before rendering to pre-warm the cache.
+func (r *Resolver) ResolveAddrsParallel(addrs []string) {
+	// dedupe and filter addresses that need resolution
+	unique := make(map[string]struct{})
+	for _, addr := range addrs {
+		if addr == "" || addr == "*" {
+			continue
+		}
+		// skip if already cached
+		r.mutex.RLock()
+		_, exists := r.cache[addr]
+		r.mutex.RUnlock()
+		if exists {
+			continue
+		}
+		unique[addr] = struct{}{}
+	}
+
+	if len(unique) == 0 {
+		return
+	}
+
+	var wg sync.WaitGroup
+	// limit concurrency to avoid overwhelming dns
+	sem := make(chan struct{}, 32)
+
+	for addr := range unique {
+		wg.Add(1)
+		go func(a string) {
+			defer wg.Done()
+			sem <- struct{}{}
+			defer func() { <-sem }()
+			r.ResolveAddr(a)
+		}(addr)
+	}
+
+	wg.Wait()
+}
+
+// ResolveAddrsParallel is a convenience function using the global resolver
+func ResolveAddrsParallel(addrs []string) {
+	GetGlobalResolver().ResolveAddrsParallel(addrs)
+}

internal/resolver/resolver_bench_test.go

@@ -0,0 +1,159 @@
+package resolver
+
+import (
+	"fmt"
+	"testing"
+	"time"
+)
+
+func BenchmarkResolveAddr_CacheHit(b *testing.B) {
+	r := New(100 * time.Millisecond)
+	addr := "127.0.0.1"
+
+	// pre-populate cache
+	r.ResolveAddr(addr)
+
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		r.ResolveAddr(addr)
+	}
+}
+
+func BenchmarkResolveAddr_CacheMiss(b *testing.B) {
+	r := New(10 * time.Millisecond) // short timeout for faster benchmarks
+
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		// use different addresses to avoid cache hits
+		addr := fmt.Sprintf("127.0.0.%d", i%256)
+		r.ClearCache() // clear cache to force miss
+		r.ResolveAddr(addr)
+	}
+}
+
+func BenchmarkResolveAddr_NoCache(b *testing.B) {
+	r := New(10 * time.Millisecond)
+	r.SetNoCache(true)
+	addr := "127.0.0.1"
+
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		r.ResolveAddr(addr)
+	}
+}
+
+func BenchmarkResolvePort_CacheHit(b *testing.B) {
+	r := New(100 * time.Millisecond)
+
+	// pre-populate cache
+	r.ResolvePort(80, "tcp")
+
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		r.ResolvePort(80, "tcp")
+	}
+}
+
+func BenchmarkResolvePort_WellKnown(b *testing.B) {
+	r := New(100 * time.Millisecond)
+
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		r.ClearCache()
+		r.ResolvePort(443, "tcp")
+	}
+}
+
+func BenchmarkGetServiceName(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		getServiceName(80, "tcp")
+	}
+}
+
+func BenchmarkGetServiceName_NotFound(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		getServiceName(12345, "tcp")
+	}
+}
+
+func BenchmarkResolveAddrsParallel_10(b *testing.B) {
+	benchmarkResolveAddrsParallel(b, 10)
+}
+
+func BenchmarkResolveAddrsParallel_100(b *testing.B) {
+	benchmarkResolveAddrsParallel(b, 100)
+}
+
+func BenchmarkResolveAddrsParallel_1000(b *testing.B) {
+	benchmarkResolveAddrsParallel(b, 1000)
+}
+
+func benchmarkResolveAddrsParallel(b *testing.B, count int) {
+	addrs := make([]string, count)
+	for i := 0; i < count; i++ {
+		addrs[i] = fmt.Sprintf("127.0.%d.%d", i/256, i%256)
+	}
+
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		r := New(10 * time.Millisecond)
+		r.ResolveAddrsParallel(addrs)
+	}
+}
+
+func BenchmarkConcurrentResolveAddr(b *testing.B) {
+	r := New(100 * time.Millisecond)
+	addr := "127.0.0.1"
+
+	// pre-populate cache
+	r.ResolveAddr(addr)
+
+	b.ResetTimer()
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			r.ResolveAddr(addr)
+		}
+	})
+}
+
+func BenchmarkConcurrentResolvePort(b *testing.B) {
+	r := New(100 * time.Millisecond)
+
+	// pre-populate cache
+	r.ResolvePort(80, "tcp")
+
+	b.ResetTimer()
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			r.ResolvePort(80, "tcp")
+		}
+	})
+}
+
+func BenchmarkGetCacheSize(b *testing.B) {
+	r := New(100 * time.Millisecond)
+
+	// populate with some entries
+	for i := 0; i < 100; i++ {
+		r.ResolvePort(i+1, "tcp")
+	}
+
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		r.GetCacheSize()
+	}
+}
+
+func BenchmarkClearCache(b *testing.B) {
+	r := New(100 * time.Millisecond)
+
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		// populate and clear
+		for j := 0; j < 10; j++ {
+			r.ResolvePort(j+1, "tcp")
+		}
+		r.ClearCache()
+	}
+}
+

internal/resolver/resolver_test.go

@@ -0,0 +1,387 @@
+package resolver
+
+import (
+	"sync"
+	"testing"
+	"time"
+)
+
+func TestNew(t *testing.T) {
+	r := New(100 * time.Millisecond)
+	if r == nil {
+		t.Fatal("expected non-nil resolver")
+	}
+	if r.timeout != 100*time.Millisecond {
+		t.Errorf("expected timeout 100ms, got %v", r.timeout)
+	}
+	if r.cache == nil {
+		t.Error("expected cache to be initialized")
+	}
+	if r.noCache {
+		t.Error("expected noCache to be false by default")
+	}
+}
+
+func TestSetNoCache(t *testing.T) {
+	r := New(100 * time.Millisecond)
+
+	r.SetNoCache(true)
+	if !r.noCache {
+		t.Error("expected noCache to be true")
+	}
+
+	r.SetNoCache(false)
+	if r.noCache {
+		t.Error("expected noCache to be false")
+	}
+}
+
+func TestResolveAddr_InvalidIP(t *testing.T) {
+	r := New(100 * time.Millisecond)
+
+	// invalid ip should return as-is
+	result := r.ResolveAddr("not-an-ip")
+	if result != "not-an-ip" {
+		t.Errorf("expected 'not-an-ip', got %q", result)
+	}
+
+	// empty string should return as-is
+	result = r.ResolveAddr("")
+	if result != "" {
+		t.Errorf("expected empty string, got %q", result)
+	}
+}
+
+func TestResolveAddr_Caching(t *testing.T) {
+	r := New(100 * time.Millisecond)
+
+	// first call should cache
+	addr := "127.0.0.1"
+	result1 := r.ResolveAddr(addr)
+
+	// verify cache is populated
+	if r.GetCacheSize() != 1 {
+		t.Errorf("expected cache size 1, got %d", r.GetCacheSize())
+	}
+
+	// second call should use cache
+	result2 := r.ResolveAddr(addr)
+	if result1 != result2 {
+		t.Errorf("expected same result from cache, got %q and %q", result1, result2)
+	}
+}
+
+func TestResolveAddr_NoCacheMode(t *testing.T) {
+	r := New(100 * time.Millisecond)
+	r.SetNoCache(true)
+
+	addr := "127.0.0.1"
+	r.ResolveAddr(addr)
+
+	// cache should remain empty when noCache is enabled
+	if r.GetCacheSize() != 0 {
+		t.Errorf("expected cache size 0 with noCache, got %d", r.GetCacheSize())
+	}
+}
+
+func TestResolvePort_Zero(t *testing.T) {
+	r := New(100 * time.Millisecond)
+
+	result := r.ResolvePort(0, "tcp")
+	if result != "0" {
+		t.Errorf("expected '0' for port 0, got %q", result)
+	}
+}
+
+func TestResolvePort_WellKnown(t *testing.T) {
+	r := New(100 * time.Millisecond)
+
+	tests := []struct {
+		port     int
+		proto    string
+		expected string
+	}{
+		{80, "tcp", "http"},
+		{443, "tcp", "https"},
+		{22, "tcp", "ssh"},
+		{53, "udp", "domain"},
+		{5432, "tcp", "postgresql"},
+	}
+
+	for _, tt := range tests {
+		result := r.ResolvePort(tt.port, tt.proto)
+		if result != tt.expected {
+			t.Errorf("ResolvePort(%d, %q) = %q, want %q", tt.port, tt.proto, result, tt.expected)
+		}
+	}
+}
+
+func TestResolvePort_Caching(t *testing.T) {
+	r := New(100 * time.Millisecond)
+
+	r.ResolvePort(80, "tcp")
+	r.ResolvePort(443, "tcp")
+
+	if r.GetCacheSize() != 2 {
+		t.Errorf("expected cache size 2, got %d", r.GetCacheSize())
+	}
+
+	// same port/proto should not add new entry
+	r.ResolvePort(80, "tcp")
+	if r.GetCacheSize() != 2 {
+		t.Errorf("expected cache size still 2, got %d", r.GetCacheSize())
+	}
+}
+
+func TestResolveAddrPort(t *testing.T) {
+	r := New(100 * time.Millisecond)
+
+	addr, port := r.ResolveAddrPort("127.0.0.1", 80, "tcp")
+
+	if addr == "" {
+		t.Error("expected non-empty address")
+	}
+	if port != "http" {
+		t.Errorf("expected port 'http', got %q", port)
+	}
+}
+
+func TestClearCache(t *testing.T) {
+	r := New(100 * time.Millisecond)
+
+	r.ResolveAddr("127.0.0.1")
+	r.ResolvePort(80, "tcp")
+
+	if r.GetCacheSize() == 0 {
+		t.Error("expected non-empty cache before clear")
+	}
+
+	r.ClearCache()
+
+	if r.GetCacheSize() != 0 {
+		t.Errorf("expected empty cache after clear, got %d", r.GetCacheSize())
+	}
+}
+
+func TestGetCacheSize(t *testing.T) {
+	r := New(100 * time.Millisecond)
+
+	if r.GetCacheSize() != 0 {
+		t.Errorf("expected initial cache size 0, got %d", r.GetCacheSize())
+	}
+
+	r.ResolveAddr("127.0.0.1")
+	if r.GetCacheSize() != 1 {
+		t.Errorf("expected cache size 1, got %d", r.GetCacheSize())
+	}
+}
+
+func TestGetServiceName(t *testing.T) {
+	tests := []struct {
+		port     int
+		proto    string
+		expected string
+	}{
+		{80, "tcp", "http"},
+		{443, "tcp", "https"},
+		{22, "tcp", "ssh"},
+		{53, "tcp", "domain"},
+		{53, "udp", "domain"},
+		{12345, "tcp", ""},
+		{0, "tcp", ""},
+	}
+
+	for _, tt := range tests {
+		result := getServiceName(tt.port, tt.proto)
+		if result != tt.expected {
+			t.Errorf("getServiceName(%d, %q) = %q, want %q", tt.port, tt.proto, result, tt.expected)
+		}
+	}
+}
+
+func TestResolveAddrsParallel(t *testing.T) {
+	r := New(100 * time.Millisecond)
+
+	addrs := []string{
+		"127.0.0.1",
+		"127.0.0.2",
+		"127.0.0.3",
+		"", // should be skipped
+		"*", // should be skipped
+	}
+
+	r.ResolveAddrsParallel(addrs)
+
+	// should have cached 3 addresses (excluding empty and *)
+	if r.GetCacheSize() != 3 {
+		t.Errorf("expected cache size 3, got %d", r.GetCacheSize())
+	}
+}
+
+func TestResolveAddrsParallel_Dedupe(t *testing.T) {
+	r := New(100 * time.Millisecond)
+
+	addrs := []string{
+		"127.0.0.1",
+		"127.0.0.1",
+		"127.0.0.1",
+		"127.0.0.2",
+	}
+
+	r.ResolveAddrsParallel(addrs)
+
+	// should have cached 2 unique addresses
+	if r.GetCacheSize() != 2 {
+		t.Errorf("expected cache size 2, got %d", r.GetCacheSize())
+	}
+}
+
+func TestResolveAddrsParallel_SkipsCached(t *testing.T) {
+	r := New(100 * time.Millisecond)
+
+	// pre-cache one address
+	r.ResolveAddr("127.0.0.1")
+
+	addrs := []string{
+		"127.0.0.1", // already cached
+		"127.0.0.2", // not cached
+	}
+
+	initialSize := r.GetCacheSize()
+	r.ResolveAddrsParallel(addrs)
+
+	// should have added 1 more
+	if r.GetCacheSize() != initialSize+1 {
+		t.Errorf("expected cache size %d, got %d", initialSize+1, r.GetCacheSize())
+	}
+}
+
+func TestResolveAddrsParallel_Empty(t *testing.T) {
+	r := New(100 * time.Millisecond)
+
+	// should not panic with empty input
+	r.ResolveAddrsParallel([]string{})
+	r.ResolveAddrsParallel(nil)
+
+	if r.GetCacheSize() != 0 {
+		t.Errorf("expected cache size 0, got %d", r.GetCacheSize())
+	}
+}
+
+func TestGlobalResolver(t *testing.T) {
+	// reset global resolver
+	globalResolver = nil
+
+	r := GetGlobalResolver()
+	if r == nil {
+		t.Fatal("expected non-nil global resolver")
+	}
+
+	// should return same instance
+	r2 := GetGlobalResolver()
+	if r != r2 {
+		t.Error("expected same global resolver instance")
+	}
+}
+
+func TestSetGlobalResolver(t *testing.T) {
+	SetGlobalResolver(ResolverOptions{
+		Timeout: 500 * time.Millisecond,
+		NoCache: true,
+	})
+
+	r := GetGlobalResolver()
+	if r.timeout != 500*time.Millisecond {
+		t.Errorf("expected timeout 500ms, got %v", r.timeout)
+	}
+	if !r.noCache {
+		t.Error("expected noCache to be true")
+	}
+
+	// reset for other tests
+	globalResolver = nil
+}
+
+func TestSetGlobalResolver_DefaultTimeout(t *testing.T) {
+	SetGlobalResolver(ResolverOptions{
+		Timeout: 0, // should use default
+	})
+
+	r := GetGlobalResolver()
+	if r.timeout != 200*time.Millisecond {
+		t.Errorf("expected default timeout 200ms, got %v", r.timeout)
+	}
+
+	// reset for other tests
+	globalResolver = nil
+}
+
+func TestGlobalConvenienceFunctions(t *testing.T) {
+	globalResolver = nil
+
+	// test global ResolveAddr
+	result := ResolveAddr("127.0.0.1")
+	if result == "" {
+		t.Error("expected non-empty result from global ResolveAddr")
+	}
+
+	// test global ResolvePort
+	port := ResolvePort(80, "tcp")
+	if port != "http" {
+		t.Errorf("expected 'http', got %q", port)
+	}
+
+	// test global ResolveAddrPort
+	addr, portStr := ResolveAddrPort("127.0.0.1", 443, "tcp")
+	if addr == "" {
+		t.Error("expected non-empty address")
+	}
+	if portStr != "https" {
+		t.Errorf("expected 'https', got %q", portStr)
+	}
+
+	// test global SetNoCache
+	SetNoCache(true)
+	if !GetGlobalResolver().noCache {
+		t.Error("expected global noCache to be true")
+	}
+
+	// reset
+	globalResolver = nil
+}
+
+func TestConcurrentAccess(t *testing.T) {
+	r := New(100 * time.Millisecond)
+
+	var wg sync.WaitGroup
+	for i := 0; i < 100; i++ {
+		wg.Add(1)
+		go func(n int) {
+			defer wg.Done()
+			addr := "127.0.0.1"
+			r.ResolveAddr(addr)
+			r.ResolvePort(80+n%10, "tcp")
+			r.GetCacheSize()
+		}(i)
+	}
+
+	wg.Wait()
+
+	// should not panic and cache should have entries
+	if r.GetCacheSize() == 0 {
+		t.Error("expected non-empty cache after concurrent access")
+	}
+}
+
+func TestResolveAddr_TrailingDot(t *testing.T) {
+	// this test verifies the trailing dot removal logic
+	// by checking the internal logic works correctly
+	r := New(100 * time.Millisecond)
+
+	// localhost should resolve and have trailing dot removed
+	result := r.ResolveAddr("127.0.0.1")
+	if len(result) > 0 && result[len(result)-1] == '.' {
+		t.Error("expected trailing dot to be removed")
+	}
+}
+

internal/testutil/testutil.go

@@ -5,7 +5,8 @@ import (
 	"path/filepath"
 	"testing"
 
-	"snitch/internal/collector"
+	"github.com/karol-broda/snitch/internal/collector"
+	"github.com/karol-broda/snitch/internal/errutil"
 )
 
 // TestCollector wraps MockCollector for use in tests
@@ -47,13 +48,13 @@ func SetupTestEnvironment(t *testing.T) (string, func()) {
 	oldConfig := os.Getenv("SNITCH_CONFIG")
 	oldNoColor := os.Getenv("SNITCH_NO_COLOR")
 	
-	os.Setenv("SNITCH_NO_COLOR", "1") // Disable colors in tests
+	errutil.Setenv("SNITCH_NO_COLOR", "1")
 	
 	// Cleanup function
 	cleanup := func() {
-		os.RemoveAll(tempDir)
-		os.Setenv("SNITCH_CONFIG", oldConfig)
-		os.Setenv("SNITCH_NO_COLOR", oldNoColor)
+		errutil.RemoveAll(tempDir)
+		errutil.Setenv("SNITCH_CONFIG", oldConfig)
+		errutil.Setenv("SNITCH_NO_COLOR", oldNoColor)
 	}
 	
 	return tempDir, cleanup
@@ -192,8 +193,8 @@ func (oc *OutputCapture) Stop() (string, string, error) {
 	os.Stderr = oc.oldStderr
 	
 	// Close files
-	oc.stdout.Close()
-	oc.stderr.Close()
+	errutil.Close(oc.stdout)
+	errutil.Close(oc.stderr)
 	
 	// Read captured content
 	stdoutContent, err := os.ReadFile(oc.stdoutFile)
@@ -207,9 +208,9 @@ func (oc *OutputCapture) Stop() (string, string, error) {
 	}
 	
 	// Cleanup
-	os.Remove(oc.stdoutFile)
-	os.Remove(oc.stderrFile)
-	os.Remove(filepath.Dir(oc.stdoutFile))
+	errutil.Remove(oc.stdoutFile)
+	errutil.Remove(oc.stderrFile)
+	errutil.Remove(filepath.Dir(oc.stdoutFile))
 	
 	return string(stdoutContent), string(stderrContent), nil
 }

internal/theme/ansi.go

@@ -0,0 +1,24 @@
+package theme
+
+// ANSI palette uses standard terminal colors (0-15)
+// this allows the theme to inherit from the user's terminal color scheme
+var paletteANSI = Palette{
+	Name: "ansi",
+
+	Fg:       "15", // bright white
+	FgMuted:  "7",  // white
+	FgSubtle: "8",  // bright black (gray)
+	Bg:       "0",  // black
+	BgMuted:  "0",  // black
+	Border:   "8",  // bright black (gray)
+
+	Red:     "1",  // red
+	Green:   "2",  // green
+	Yellow:  "3",  // yellow
+	Blue:    "4",  // blue
+	Magenta: "5",  // magenta
+	Cyan:    "6",  // cyan
+	Orange:  "3",  // yellow (ansi has no orange, fallback to yellow)
+	Gray:    "8",  // bright black
+}
+

internal/theme/catppuccin.go

@@ -0,0 +1,87 @@
+package theme
+
+// catppuccin mocha (dark)
+// https://github.com/catppuccin/catppuccin
+var paletteCatppuccinMocha = Palette{
+	Name: "catppuccin-mocha",
+
+	Fg:       "#cdd6f4", // text
+	FgMuted:  "#a6adc8", // subtext0
+	FgSubtle: "#6c7086", // overlay0
+	Bg:       "#1e1e2e", // base
+	BgMuted:  "#313244", // surface0
+	Border:   "#45475a", // surface1
+
+	Red:     "#f38ba8",
+	Green:   "#a6e3a1",
+	Yellow:  "#f9e2af",
+	Blue:    "#89b4fa",
+	Magenta: "#cba6f7", // mauve
+	Cyan:    "#94e2d5", // teal
+	Orange:  "#fab387", // peach
+	Gray:    "#585b70", // surface2
+}
+
+// catppuccin macchiato (medium-dark)
+var paletteCatppuccinMacchiato = Palette{
+	Name: "catppuccin-macchiato",
+
+	Fg:       "#cad3f5", // text
+	FgMuted:  "#a5adcb", // subtext0
+	FgSubtle: "#6e738d", // overlay0
+	Bg:       "#24273a", // base
+	BgMuted:  "#363a4f", // surface0
+	Border:   "#494d64", // surface1
+
+	Red:     "#ed8796",
+	Green:   "#a6da95",
+	Yellow:  "#eed49f",
+	Blue:    "#8aadf4",
+	Magenta: "#c6a0f6", // mauve
+	Cyan:    "#8bd5ca", // teal
+	Orange:  "#f5a97f", // peach
+	Gray:    "#5b6078", // surface2
+}
+
+// catppuccin frappe (medium)
+var paletteCatppuccinFrappe = Palette{
+	Name: "catppuccin-frappe",
+
+	Fg:       "#c6d0f5", // text
+	FgMuted:  "#a5adce", // subtext0
+	FgSubtle: "#737994", // overlay0
+	Bg:       "#303446", // base
+	BgMuted:  "#414559", // surface0
+	Border:   "#51576d", // surface1
+
+	Red:     "#e78284",
+	Green:   "#a6d189",
+	Yellow:  "#e5c890",
+	Blue:    "#8caaee",
+	Magenta: "#ca9ee6", // mauve
+	Cyan:    "#81c8be", // teal
+	Orange:  "#ef9f76", // peach
+	Gray:    "#626880", // surface2
+}
+
+// catppuccin latte (light)
+var paletteCatppuccinLatte = Palette{
+	Name: "catppuccin-latte",
+
+	Fg:       "#4c4f69", // text
+	FgMuted:  "#6c6f85", // subtext0
+	FgSubtle: "#9ca0b0", // overlay0
+	Bg:       "#eff1f5", // base
+	BgMuted:  "#ccd0da", // surface0
+	Border:   "#bcc0cc", // surface1
+
+	Red:     "#d20f39",
+	Green:   "#40a02b",
+	Yellow:  "#df8e1d",
+	Blue:    "#1e66f5",
+	Magenta: "#8839ef", // mauve
+	Cyan:    "#179299", // teal
+	Orange:  "#fe640b", // peach
+	Gray:    "#acb0be", // surface2
+}
+

internal/theme/dracula.go

@@ -0,0 +1,24 @@
+package theme
+
+// dracula theme
+// https://draculatheme.com/
+var paletteDracula = Palette{
+	Name: "dracula",
+
+	Fg:       "#f8f8f2", // foreground
+	FgMuted:  "#f8f8f2", // foreground
+	FgSubtle: "#6272a4", // comment
+	Bg:       "#282a36", // background
+	BgMuted:  "#44475a", // selection
+	Border:   "#44475a", // selection
+
+	Red:     "#ff5555",
+	Green:   "#50fa7b",
+	Yellow:  "#f1fa8c",
+	Blue:    "#6272a4", // dracula uses comment color for blue tones
+	Magenta: "#bd93f9", // purple
+	Cyan:    "#8be9fd",
+	Orange:  "#ffb86c",
+	Gray:    "#6272a4", // comment
+}
+

internal/theme/gruvbox.go

@@ -0,0 +1,45 @@
+package theme
+
+// gruvbox dark
+// https://github.com/morhetz/gruvbox
+var paletteGruvboxDark = Palette{
+	Name: "gruvbox-dark",
+
+	Fg:       "#ebdbb2", // fg
+	FgMuted:  "#d5c4a1", // fg2
+	FgSubtle: "#a89984", // fg4
+	Bg:       "#282828", // bg
+	BgMuted:  "#3c3836", // bg1
+	Border:   "#504945", // bg2
+
+	Red:     "#fb4934",
+	Green:   "#b8bb26",
+	Yellow:  "#fabd2f",
+	Blue:    "#83a598",
+	Magenta: "#d3869b", // purple
+	Cyan:    "#8ec07c", // aqua
+	Orange:  "#fe8019",
+	Gray:    "#928374",
+}
+
+// gruvbox light
+var paletteGruvboxLight = Palette{
+	Name: "gruvbox-light",
+
+	Fg:       "#3c3836", // fg
+	FgMuted:  "#504945", // fg2
+	FgSubtle: "#7c6f64", // fg4
+	Bg:       "#fbf1c7", // bg
+	BgMuted:  "#ebdbb2", // bg1
+	Border:   "#d5c4a1", // bg2
+
+	Red:     "#cc241d",
+	Green:   "#98971a",
+	Yellow:  "#d79921",
+	Blue:    "#458588",
+	Magenta: "#b16286", // purple
+	Cyan:    "#689d6a", // aqua
+	Orange:  "#d65d0e",
+	Gray:    "#928374",
+}
+

internal/theme/mono.go

@@ -0,0 +1,49 @@
+package theme
+
+import "github.com/charmbracelet/lipgloss"
+
+// createMonoTheme creates a monochrome theme (no colors)
+// useful for accessibility, piping output, or minimal terminals
+func createMonoTheme() *Theme {
+	baseStyle := lipgloss.NewStyle()
+	boldStyle := lipgloss.NewStyle().Bold(true)
+
+	return &Theme{
+		Name: "mono",
+		Styles: Styles{
+			Header:     boldStyle,
+			Border:     baseStyle,
+			Selected:   boldStyle,
+			Watched:    boldStyle,
+			Normal:     baseStyle,
+			Error:      boldStyle,
+			Success:    boldStyle,
+			Warning:    boldStyle,
+			Footer:     baseStyle,
+			Background: baseStyle,
+
+			Proto: ProtoStyles{
+				TCP:  baseStyle,
+				UDP:  baseStyle,
+				Unix: baseStyle,
+				TCP6: baseStyle,
+				UDP6: baseStyle,
+			},
+
+			State: StateStyles{
+				Listen:      baseStyle,
+				Established: baseStyle,
+				TimeWait:    baseStyle,
+				CloseWait:   baseStyle,
+				SynSent:     baseStyle,
+				SynRecv:     baseStyle,
+				FinWait1:    baseStyle,
+				FinWait2:    baseStyle,
+				Closing:     baseStyle,
+				LastAck:     baseStyle,
+				Closed:      baseStyle,
+			},
+		},
+	}
+}
+

internal/theme/nord.go

@@ -0,0 +1,24 @@
+package theme
+
+// nord theme
+// https://www.nordtheme.com/
+var paletteNord = Palette{
+	Name: "nord",
+
+	Fg:       "#eceff4", // snow storm - nord6
+	FgMuted:  "#d8dee9", // snow storm - nord4
+	FgSubtle: "#4c566a", // polar night - nord3
+	Bg:       "#2e3440", // polar night - nord0
+	BgMuted:  "#3b4252", // polar night - nord1
+	Border:   "#434c5e", // polar night - nord2
+
+	Red:     "#bf616a", // aurora - nord11
+	Green:   "#a3be8c", // aurora - nord14
+	Yellow:  "#ebcb8b", // aurora - nord13
+	Blue:    "#81a1c1", // frost - nord9
+	Magenta: "#b48ead", // aurora - nord15
+	Cyan:    "#88c0d0", // frost - nord8
+	Orange:  "#d08770", // aurora - nord12
+	Gray:    "#4c566a", // polar night - nord3
+}
+

internal/theme/one_dark.go

@@ -0,0 +1,24 @@
+package theme
+
+// one dark theme (atom editor)
+// https://github.com/atom/atom/tree/master/packages/one-dark-syntax
+var paletteOneDark = Palette{
+	Name: "one-dark",
+
+	Fg:       "#abb2bf", // foreground
+	FgMuted:  "#9da5b4", // foreground muted
+	FgSubtle: "#5c6370", // comment
+	Bg:       "#282c34", // background
+	BgMuted:  "#21252b", // gutter background
+	Border:   "#3e4451", // selection
+
+	Red:     "#e06c75",
+	Green:   "#98c379",
+	Yellow:  "#e5c07b",
+	Blue:    "#61afef",
+	Magenta: "#c678dd", // purple
+	Cyan:    "#56b6c2",
+	Orange:  "#d19a66",
+	Gray:    "#5c6370", // comment
+}
+

internal/theme/palette.go

@@ -0,0 +1,111 @@
+package theme
+
+import (
+	"strconv"
+
+	"github.com/charmbracelet/lipgloss"
+)
+
+// Palette defines the semantic colors for a theme
+type Palette struct {
+	Name string
+
+	// base colors
+	Fg       string // primary foreground
+	FgMuted  string // secondary/muted foreground
+	FgSubtle string // subtle/disabled foreground
+	Bg       string // primary background
+	BgMuted  string // secondary background (selections, highlights)
+	Border   string // border color
+
+	// semantic colors
+	Red     string
+	Green   string
+	Yellow  string
+	Blue    string
+	Magenta string
+	Cyan    string
+	Orange  string
+	Gray    string
+}
+
+// Color converts a palette color string to a lipgloss.TerminalColor.
+// If the string is 1-2 characters, it's treated as an ANSI color code.
+// Otherwise, it's treated as a hex color.
+func (p *Palette) Color(c string) lipgloss.TerminalColor {
+	if c == "" {
+		return lipgloss.NoColor{}
+	}
+
+	if len(c) <= 2 {
+		n, err := strconv.Atoi(c)
+		if err == nil {
+			return lipgloss.ANSIColor(n)
+		}
+	}
+
+	return lipgloss.Color(c)
+}
+
+// ToTheme converts a Palette to a Theme with lipgloss styles
+func (p *Palette) ToTheme() *Theme {
+	return &Theme{
+		Name: p.Name,
+		Styles: Styles{
+			Header: lipgloss.NewStyle().
+				Bold(true).
+				Foreground(p.Color(p.Fg)),
+
+			Border: lipgloss.NewStyle().
+				Foreground(p.Color(p.Border)),
+
+			Selected: lipgloss.NewStyle().
+				Bold(true).
+				Foreground(p.Color(p.Fg)),
+
+			Watched: lipgloss.NewStyle().
+				Bold(true).
+				Foreground(p.Color(p.Orange)),
+
+			Normal: lipgloss.NewStyle().
+				Foreground(p.Color(p.FgMuted)),
+
+			Error: lipgloss.NewStyle().
+				Foreground(p.Color(p.Red)),
+
+			Success: lipgloss.NewStyle().
+				Foreground(p.Color(p.Green)),
+
+			Warning: lipgloss.NewStyle().
+				Foreground(p.Color(p.Yellow)),
+
+			Footer: lipgloss.NewStyle().
+				Foreground(p.Color(p.FgSubtle)),
+
+			Background: lipgloss.NewStyle(),
+
+			Proto: ProtoStyles{
+				TCP:  lipgloss.NewStyle().Foreground(p.Color(p.Green)),
+				UDP:  lipgloss.NewStyle().Foreground(p.Color(p.Magenta)),
+				Unix: lipgloss.NewStyle().Foreground(p.Color(p.Gray)),
+				TCP6: lipgloss.NewStyle().Foreground(p.Color(p.Cyan)),
+				UDP6: lipgloss.NewStyle().Foreground(p.Color(p.Blue)),
+			},
+
+			State: StateStyles{
+				Listen:      lipgloss.NewStyle().Foreground(p.Color(p.Green)),
+				Established: lipgloss.NewStyle().Foreground(p.Color(p.Blue)),
+				TimeWait:    lipgloss.NewStyle().Foreground(p.Color(p.Yellow)),
+				CloseWait:   lipgloss.NewStyle().Foreground(p.Color(p.Orange)),
+				SynSent:     lipgloss.NewStyle().Foreground(p.Color(p.Magenta)),
+				SynRecv:     lipgloss.NewStyle().Foreground(p.Color(p.Magenta)),
+				FinWait1:    lipgloss.NewStyle().Foreground(p.Color(p.Red)),
+				FinWait2:    lipgloss.NewStyle().Foreground(p.Color(p.Red)),
+				Closing:     lipgloss.NewStyle().Foreground(p.Color(p.Red)),
+				LastAck:     lipgloss.NewStyle().Foreground(p.Color(p.Red)),
+				Closed:      lipgloss.NewStyle().Foreground(p.Color(p.Gray)),
+			},
+		},
+	}
+}
+

internal/theme/readme.md

@@ -0,0 +1,14 @@
+# theme Palettes
+
+the color palettes in this directory were generated by an LLM agent (Claude Opus 4.5) using web search to fetch the official color specifications from each themes documentation
+as it is with llm agents its possible the colors may be wrong
+
+Sources:
+- [Catppuccin](https://github.com/catppuccin/catppuccin)
+- [Dracula](https://draculatheme.com/)
+- [Gruvbox](https://github.com/morhetz/gruvbox)
+- [Nord](https://www.nordtheme.com/)
+- [One Dark](https://github.com/atom/one-dark-syntax)
+- [Solarized](https://ethanschoonover.com/solarized/)
+- [Tokyo Night](https://github.com/enkia/tokyo-night-vscode-theme)
+

internal/theme/solarized.go

@@ -0,0 +1,45 @@
+package theme
+
+// solarized dark theme
+// https://ethanschoonover.com/solarized/
+var paletteSolarizedDark = Palette{
+	Name: "solarized-dark",
+
+	Fg:       "#839496", // base0
+	FgMuted:  "#93a1a1", // base1
+	FgSubtle: "#586e75", // base01
+	Bg:       "#002b36", // base03
+	BgMuted:  "#073642", // base02
+	Border:   "#073642", // base02
+
+	Red:     "#dc322f",
+	Green:   "#859900",
+	Yellow:  "#b58900",
+	Blue:    "#268bd2",
+	Magenta: "#d33682",
+	Cyan:    "#2aa198",
+	Orange:  "#cb4b16",
+	Gray:    "#657b83", // base00
+}
+
+// solarized light theme
+var paletteSolarizedLight = Palette{
+	Name: "solarized-light",
+
+	Fg:       "#657b83", // base00
+	FgMuted:  "#586e75", // base01
+	FgSubtle: "#93a1a1", // base1
+	Bg:       "#fdf6e3", // base3
+	BgMuted:  "#eee8d5", // base2
+	Border:   "#eee8d5", // base2
+
+	Red:     "#dc322f",
+	Green:   "#859900",
+	Yellow:  "#b58900",
+	Blue:    "#268bd2",
+	Magenta: "#d33682",
+	Cyan:    "#2aa198",
+	Orange:  "#cb4b16",
+	Gray:    "#839496", // base0
+}
+

internal/theme/theme.go

@@ -1,6 +1,7 @@
 package theme
 
 import (
+	"sort"
 	"strings"
 
 	"github.com/charmbracelet/lipgloss"
@@ -52,152 +53,73 @@ type StateStyles struct {
 	Closed      lipgloss.Style
 }
 
-var (
-	themes map[string]*Theme
-)
+var themes map[string]*Theme
 
 func init() {
-	themes = map[string]*Theme{
-		"default": createAdaptiveTheme(),
-		"mono":    createMonoTheme(),
-	}
+	themes = make(map[string]*Theme)
+
+	// ansi theme (default) - inherits from terminal colors
+	themes["ansi"] = paletteANSI.ToTheme()
+
+	// catppuccin variants
+	themes["catppuccin-mocha"] = paletteCatppuccinMocha.ToTheme()
+	themes["catppuccin-macchiato"] = paletteCatppuccinMacchiato.ToTheme()
+	themes["catppuccin-frappe"] = paletteCatppuccinFrappe.ToTheme()
+	themes["catppuccin-latte"] = paletteCatppuccinLatte.ToTheme()
+
+	// gruvbox variants
+	themes["gruvbox-dark"] = paletteGruvboxDark.ToTheme()
+	themes["gruvbox-light"] = paletteGruvboxLight.ToTheme()
+
+	// dracula
+	themes["dracula"] = paletteDracula.ToTheme()
+
+	// nord
+	themes["nord"] = paletteNord.ToTheme()
+
+	// tokyo night variants
+	themes["tokyo-night"] = paletteTokyoNight.ToTheme()
+	themes["tokyo-night-storm"] = paletteTokyoNightStorm.ToTheme()
+	themes["tokyo-night-light"] = paletteTokyoNightLight.ToTheme()
+
+	// solarized variants
+	themes["solarized-dark"] = paletteSolarizedDark.ToTheme()
+	themes["solarized-light"] = paletteSolarizedLight.ToTheme()
+
+	// one dark
+	themes["one-dark"] = paletteOneDark.ToTheme()
+
+	// monochrome (no colors)
+	themes["mono"] = createMonoTheme()
 }
 
-// GetTheme returns a theme by name, with auto-detection support
+// DefaultTheme is the theme used when none is specified
+const DefaultTheme = "ansi"
+
+// GetTheme returns a theme by name
 func GetTheme(name string) *Theme {
-	if name == "auto" {
-		// lipgloss handles adaptive colors, so we just return the default
-		return themes["default"]
+	if name == "" || name == "auto" || name == "default" {
+		return themes[DefaultTheme]
 	}
 
 	if theme, exists := themes[name]; exists {
 		return theme
 	}
 
-	// a specific theme was requested (e.g. "dark", "light"), but we now use adaptive
-	// so we can just return the default theme and lipgloss will handle it
-	if name == "dark" || name == "light" {
-		return themes["default"]
-	}
-
 	// fallback to default
-	return themes["default"]
+	return themes[DefaultTheme]
 }
 
-// ListThemes returns available theme names
+// ListThemes returns available theme names sorted alphabetically
 func ListThemes() []string {
-	var names []string
+	names := make([]string, 0, len(themes))
 	for name := range themes {
 		names = append(names, name)
 	}
+	sort.Strings(names)
 	return names
 }
 
-// createAdaptiveTheme creates a clean, minimal theme
-func createAdaptiveTheme() *Theme {
-	return &Theme{
-		Name: "default",
-		Styles: Styles{
-			Header: lipgloss.NewStyle().
-				Bold(true).
-				Foreground(lipgloss.AdaptiveColor{Light: "#1F2937", Dark: "#F9FAFB"}),
-
-			Watched: lipgloss.NewStyle().
-				Bold(true).
-				Foreground(lipgloss.AdaptiveColor{Light: "#D97706", Dark: "#F59E0B"}),
-
-			Border: lipgloss.NewStyle().
-				Foreground(lipgloss.AdaptiveColor{Light: "#D1D5DB", Dark: "#374151"}),
-
-			Selected: lipgloss.NewStyle().
-				Bold(true).
-				Foreground(lipgloss.AdaptiveColor{Light: "#1F2937", Dark: "#F9FAFB"}),
-
-			Normal: lipgloss.NewStyle().
-				Foreground(lipgloss.AdaptiveColor{Light: "#6B7280", Dark: "#9CA3AF"}),
-
-			Error: lipgloss.NewStyle().
-				Foreground(lipgloss.AdaptiveColor{Light: "#DC2626", Dark: "#F87171"}),
-
-			Success: lipgloss.NewStyle().
-				Foreground(lipgloss.AdaptiveColor{Light: "#059669", Dark: "#34D399"}),
-
-			Warning: lipgloss.NewStyle().
-				Foreground(lipgloss.AdaptiveColor{Light: "#D97706", Dark: "#FBBF24"}),
-
-			Footer: lipgloss.NewStyle().
-				Foreground(lipgloss.AdaptiveColor{Light: "#9CA3AF", Dark: "#6B7280"}),
-
-			Background: lipgloss.NewStyle(),
-
-			Proto: ProtoStyles{
-				TCP:  lipgloss.NewStyle().Foreground(lipgloss.AdaptiveColor{Light: "#059669", Dark: "#34D399"}),
-				UDP:  lipgloss.NewStyle().Foreground(lipgloss.AdaptiveColor{Light: "#7C3AED", Dark: "#A78BFA"}),
-				Unix: lipgloss.NewStyle().Foreground(lipgloss.AdaptiveColor{Light: "#6B7280", Dark: "#9CA3AF"}),
-				TCP6: lipgloss.NewStyle().Foreground(lipgloss.AdaptiveColor{Light: "#059669", Dark: "#34D399"}),
-				UDP6: lipgloss.NewStyle().Foreground(lipgloss.AdaptiveColor{Light: "#7C3AED", Dark: "#A78BFA"}),
-			},
-
-			State: StateStyles{
-				Listen:      lipgloss.NewStyle().Foreground(lipgloss.AdaptiveColor{Light: "#059669", Dark: "#34D399"}),
-				Established: lipgloss.NewStyle().Foreground(lipgloss.AdaptiveColor{Light: "#2563EB", Dark: "#60A5FA"}),
-				TimeWait:    lipgloss.NewStyle().Foreground(lipgloss.AdaptiveColor{Light: "#D97706", Dark: "#FBBF24"}),
-				CloseWait:   lipgloss.NewStyle().Foreground(lipgloss.AdaptiveColor{Light: "#D97706", Dark: "#FBBF24"}),
-				SynSent:     lipgloss.NewStyle().Foreground(lipgloss.AdaptiveColor{Light: "#7C3AED", Dark: "#A78BFA"}),
-				SynRecv:     lipgloss.NewStyle().Foreground(lipgloss.AdaptiveColor{Light: "#7C3AED", Dark: "#A78BFA"}),
-				FinWait1:    lipgloss.NewStyle().Foreground(lipgloss.AdaptiveColor{Light: "#DC2626", Dark: "#F87171"}),
-				FinWait2:    lipgloss.NewStyle().Foreground(lipgloss.AdaptiveColor{Light: "#DC2626", Dark: "#F87171"}),
-				Closing:     lipgloss.NewStyle().Foreground(lipgloss.AdaptiveColor{Light: "#DC2626", Dark: "#F87171"}),
-				LastAck:     lipgloss.NewStyle().Foreground(lipgloss.AdaptiveColor{Light: "#DC2626", Dark: "#F87171"}),
-				Closed:      lipgloss.NewStyle().Foreground(lipgloss.AdaptiveColor{Light: "#9CA3AF", Dark: "#6B7280"}),
-			},
-		},
-	}
-}
-
-// createMonoTheme creates a monochrome theme (no colors)
-func createMonoTheme() *Theme {
-	baseStyle := lipgloss.NewStyle()
-	boldStyle := lipgloss.NewStyle().Bold(true)
-
-	return &Theme{
-		Name: "mono",
-		Styles: Styles{
-			Header:     boldStyle,
-			Border:     baseStyle,
-			Selected:   boldStyle,
-			Normal:     baseStyle,
-			Error:      boldStyle,
-			Success:    boldStyle,
-			Warning:    boldStyle,
-			Footer:     baseStyle,
-			Background: baseStyle,
-
-			Proto: ProtoStyles{
-				TCP:  baseStyle,
-				UDP:  baseStyle,
-				Unix: baseStyle,
-				TCP6: baseStyle,
-				UDP6: baseStyle,
-			},
-
-			State: StateStyles{
-				Listen:      baseStyle,
-				Established: baseStyle,
-				TimeWait:    baseStyle,
-				CloseWait:   baseStyle,
-				SynSent:     baseStyle,
-				SynRecv:     baseStyle,
-				FinWait1:    baseStyle,
-				FinWait2:    baseStyle,
-				Closing:     baseStyle,
-				LastAck:     baseStyle,
-				Closed:      baseStyle,
-			},
-		},
-	}
-}
-
 // GetProtoStyle returns the appropriate style for a protocol
 func (s *Styles) GetProtoStyle(proto string) lipgloss.Style {
 	switch strings.ToLower(proto) {

internal/theme/tokyo_night.go

@@ -0,0 +1,66 @@
+package theme
+
+// tokyo night theme
+// https://github.com/enkia/tokyo-night-vscode-theme
+var paletteTokyoNight = Palette{
+	Name: "tokyo-night",
+
+	Fg:       "#c0caf5", // foreground
+	FgMuted:  "#a9b1d6", // foreground dark
+	FgSubtle: "#565f89", // comment
+	Bg:       "#1a1b26", // background
+	BgMuted:  "#24283b", // background highlight
+	Border:   "#414868", // border
+
+	Red:     "#f7768e",
+	Green:   "#9ece6a",
+	Yellow:  "#e0af68",
+	Blue:    "#7aa2f7",
+	Magenta: "#bb9af7", // purple
+	Cyan:    "#7dcfff",
+	Orange:  "#ff9e64",
+	Gray:    "#565f89", // comment
+}
+
+// tokyo night storm variant
+var paletteTokyoNightStorm = Palette{
+	Name: "tokyo-night-storm",
+
+	Fg:       "#c0caf5", // foreground
+	FgMuted:  "#a9b1d6", // foreground dark
+	FgSubtle: "#565f89", // comment
+	Bg:       "#24283b", // background (storm is slightly lighter)
+	BgMuted:  "#1f2335", // background dark
+	Border:   "#414868", // border
+
+	Red:     "#f7768e",
+	Green:   "#9ece6a",
+	Yellow:  "#e0af68",
+	Blue:    "#7aa2f7",
+	Magenta: "#bb9af7", // purple
+	Cyan:    "#7dcfff",
+	Orange:  "#ff9e64",
+	Gray:    "#565f89", // comment
+}
+
+// tokyo night light variant
+var paletteTokyoNightLight = Palette{
+	Name: "tokyo-night-light",
+
+	Fg:       "#343b58", // foreground
+	FgMuted:  "#565a6e", // foreground dark
+	FgSubtle: "#9699a3", // comment
+	Bg:       "#d5d6db", // background
+	BgMuted:  "#cbccd1", // background highlight
+	Border:   "#b4b5b9", // border
+
+	Red:     "#8c4351",
+	Green:   "#485e30",
+	Yellow:  "#8f5e15",
+	Blue:    "#34548a",
+	Magenta: "#5a4a78", // purple
+	Cyan:    "#0f4b6e",
+	Orange:  "#965027",
+	Gray:    "#9699a3", // comment
+}
+

internal/tui/helpers.go

@@ -1,9 +1,8 @@
 package tui
 
 import (
-	"fmt"
 	"regexp"
-	"snitch/internal/collector"
+	"github.com/karol-broda/snitch/internal/collector"
 	"strings"
 )
 
@@ -44,10 +43,3 @@ func sortFieldLabel(f collector.SortField) string {
 	}
 }
 
-func formatRemote(addr string, port int) string {
-	if addr == "" || addr == "*" || port == 0 {
-		return "-"
-	}
-	return fmt.Sprintf("%s:%d", addr, port)
-}
-

internal/tui/keys.go

@@ -2,7 +2,7 @@ package tui
 
 import (
 	"fmt"
-	"snitch/internal/collector"
+	"github.com/karol-broda/snitch/internal/collector"
 	"time"
 
 	tea "github.com/charmbracelet/bubbletea"
@@ -210,6 +210,28 @@ func (m model) handleNormalKey(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
 				m.showKillConfirm = true
 			}
 		}
+
+	// toggle address resolution
+	case "n":
+		m.resolveAddrs = !m.resolveAddrs
+		if m.resolveAddrs {
+			m.statusMessage = "address resolution: on"
+		} else {
+			m.statusMessage = "address resolution: off"
+		}
+		m.statusExpiry = time.Now().Add(2 * time.Second)
+		return m, clearStatusAfter(2 * time.Second)
+
+	// toggle port resolution
+	case "N":
+		m.resolvePorts = !m.resolvePorts
+		if m.resolvePorts {
+			m.statusMessage = "port resolution: on"
+		} else {
+			m.statusMessage = "port resolution: off"
+		}
+		m.statusExpiry = time.Now().Add(2 * time.Second)
+		return m, clearStatusAfter(2 * time.Second)
 	}
 
 	return m, nil

internal/tui/messages.go

@@ -2,7 +2,8 @@ package tui
 
 import (
 	"fmt"
-	"snitch/internal/collector"
+	"github.com/karol-broda/snitch/internal/collector"
+	"github.com/karol-broda/snitch/internal/resolver"
 	"syscall"
 	"time"
 
@@ -35,11 +36,20 @@ func (m model) tick() tea.Cmd {
 }
 
 func (m model) fetchData() tea.Cmd {
+	resolveAddrs := m.resolveAddrs
 	return func() tea.Msg {
 		conns, err := collector.GetConnections()
 		if err != nil {
 			return errMsg{err}
 		}
+		// pre-warm dns cache in parallel if resolution is enabled
+		if resolveAddrs {
+			addrs := make([]string, 0, len(conns)*2)
+			for _, c := range conns {
+				addrs = append(addrs, c.Laddr, c.Raddr)
+			}
+			resolver.ResolveAddrsParallel(addrs)
+		}
 		return dataMsg{connections: conns}
 	}
 }

internal/tui/model.go

@@ -2,8 +2,8 @@ package tui
 
 import (
 	"fmt"
-	"snitch/internal/collector"
-	"snitch/internal/theme"
+	"github.com/karol-broda/snitch/internal/collector"
+	"github.com/karol-broda/snitch/internal/theme"
 	"time"
 
 	tea "github.com/charmbracelet/bubbletea"
@@ -28,6 +28,10 @@ type model struct {
 	sortField   collector.SortField
 	sortReverse bool
 
+	// display options
+	resolveAddrs bool // when true, resolve IP addresses to hostnames
+	resolvePorts bool // when true, resolve port numbers to service names
+
 	// ui state
 	theme       *theme.Theme
 	showHelp    bool
@@ -58,6 +62,9 @@ type Options struct {
 	Established  bool
 	Other        bool
 	FilterSet    bool // true if user specified any filter flags
+	ResolveAddrs bool // when true, resolve IP addresses to hostnames
+	ResolvePorts bool // when true, resolve port numbers to service names
+	NoCache      bool // when true, disable DNS caching
 }
 
 func New(opts Options) model {
@@ -102,6 +109,8 @@ func New(opts Options) model {
 		showEstablished: showEstablished,
 		showOther:       showOther,
 		sortField:       collector.SortByLport,
+		resolveAddrs:    opts.ResolveAddrs,
+		resolvePorts:    opts.ResolvePorts,
 		theme:           theme.GetTheme(opts.Theme),
 		interval:        interval,
 		lastRefresh:     time.Now(),

internal/tui/model_test.go

@@ -1,7 +1,7 @@
 package tui
 
 import (
-	"snitch/internal/collector"
+	"github.com/karol-broda/snitch/internal/collector"
 	"testing"
 	"time"
 
@@ -301,3 +301,132 @@ func TestTUI_ViewRenders(t *testing.T) {
 	}
 }
 
+func TestTUI_ResolutionOptions(t *testing.T) {
+	// test default resolution settings
+	m := New(Options{Theme: "dark", Interval: time.Hour})
+
+	if m.resolveAddrs != false {
+		t.Error("expected resolveAddrs to be false by default (must be explicitly set)")
+	}
+	if m.resolvePorts != false {
+		t.Error("expected resolvePorts to be false by default")
+	}
+
+	// test with explicit options
+	m2 := New(Options{
+		Theme:        "dark",
+		Interval:     time.Hour,
+		ResolveAddrs: true,
+		ResolvePorts: true,
+	})
+
+	if m2.resolveAddrs != true {
+		t.Error("expected resolveAddrs to be true when set")
+	}
+	if m2.resolvePorts != true {
+		t.Error("expected resolvePorts to be true when set")
+	}
+}
+
+func TestTUI_ToggleResolution(t *testing.T) {
+	m := New(Options{Theme: "dark", Interval: time.Hour, ResolveAddrs: true})
+
+	if m.resolveAddrs != true {
+		t.Fatal("expected resolveAddrs to be true initially")
+	}
+
+	// toggle address resolution with 'n'
+	newModel, _ := m.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{'n'}})
+	m = newModel.(model)
+
+	if m.resolveAddrs != false {
+		t.Error("expected resolveAddrs to be false after toggle")
+	}
+
+	// toggle back
+	newModel, _ = m.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{'n'}})
+	m = newModel.(model)
+
+	if m.resolveAddrs != true {
+		t.Error("expected resolveAddrs to be true after second toggle")
+	}
+
+	// toggle port resolution with 'N'
+	if m.resolvePorts != false {
+		t.Fatal("expected resolvePorts to be false initially")
+	}
+
+	newModel, _ = m.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{'N'}})
+	m = newModel.(model)
+
+	if m.resolvePorts != true {
+		t.Error("expected resolvePorts to be true after toggle")
+	}
+
+	// toggle back
+	newModel, _ = m.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{'N'}})
+	m = newModel.(model)
+
+	if m.resolvePorts != false {
+		t.Error("expected resolvePorts to be false after second toggle")
+	}
+}
+
+func TestTUI_ResolveAddrHelper(t *testing.T) {
+	m := New(Options{Theme: "dark", Interval: time.Hour})
+	m.resolveAddrs = false
+
+	// when resolution is off, should return original address
+	addr := m.resolveAddr("192.168.1.1")
+	if addr != "192.168.1.1" {
+		t.Errorf("expected original address when resolution off, got %s", addr)
+	}
+
+	// empty and wildcard addresses should pass through unchanged
+	if m.resolveAddr("") != "" {
+		t.Error("expected empty string to pass through")
+	}
+	if m.resolveAddr("*") != "*" {
+		t.Error("expected wildcard to pass through")
+	}
+}
+
+func TestTUI_ResolvePortHelper(t *testing.T) {
+	m := New(Options{Theme: "dark", Interval: time.Hour})
+	m.resolvePorts = false
+
+	// when resolution is off, should return port number as string
+	port := m.resolvePort(80, "tcp")
+	if port != "80" {
+		t.Errorf("expected '80' when resolution off, got %s", port)
+	}
+
+	port = m.resolvePort(443, "tcp")
+	if port != "443" {
+		t.Errorf("expected '443' when resolution off, got %s", port)
+	}
+}
+
+func TestTUI_FormatRemoteHelper(t *testing.T) {
+	m := New(Options{Theme: "dark", Interval: time.Hour})
+	m.resolveAddrs = false
+	m.resolvePorts = false
+
+	// empty/wildcard addresses should return dash
+	if m.formatRemote("", 80, "tcp") != "-" {
+		t.Error("expected dash for empty address")
+	}
+	if m.formatRemote("*", 80, "tcp") != "-" {
+		t.Error("expected dash for wildcard address")
+	}
+	if m.formatRemote("192.168.1.1", 0, "tcp") != "-" {
+		t.Error("expected dash for zero port")
+	}
+
+	// valid address:port should format correctly
+	result := m.formatRemote("192.168.1.1", 443, "tcp")
+	if result != "192.168.1.1:443" {
+		t.Errorf("expected '192.168.1.1:443', got %s", result)
+	}
+}
+

internal/tui/symbols.go

@@ -15,6 +15,7 @@ const (
 	SymbolArrowDown  = string('\u2193') // downwards arrow
 	SymbolRefresh    = string('\u21BB') // clockwise open circle arrow
 	SymbolEllipsis   = string('\u2026') // horizontal ellipsis
+	SymbolDownload   = string('\u21E9') // downwards white arrow
 
 	// box drawing rounded 
 	BoxTopLeft     = string('\u256D') // light arc down and right

internal/tui/view.go

@@ -2,7 +2,9 @@ package tui
 
 import (
 	"fmt"
-	"snitch/internal/collector"
+	"github.com/karol-broda/snitch/internal/collector"
+	"github.com/karol-broda/snitch/internal/resolver"
+	"strconv"
 	"strings"
 	"time"
 
@@ -47,37 +49,14 @@ func (m model) renderTitle() string {
 func (m model) renderFilters() string {
 	var parts []string
 
-	if m.showTCP {
-		parts = append(parts, m.theme.Styles.Success.Render("tcp"))
-	} else {
-		parts = append(parts, m.theme.Styles.Normal.Render("tcp"))
-	}
-
-	if m.showUDP {
-		parts = append(parts, m.theme.Styles.Success.Render("udp"))
-	} else {
-		parts = append(parts, m.theme.Styles.Normal.Render("udp"))
-	}
+	parts = append(parts, m.renderFilterLabel("t", "cp", m.showTCP))
+	parts = append(parts, m.renderFilterLabel("u", "dp", m.showUDP))
 
 	parts = append(parts, m.theme.Styles.Border.Render(BoxVertical))
 
-	if m.showListening {
-		parts = append(parts, m.theme.Styles.Success.Render("listen"))
-	} else {
-		parts = append(parts, m.theme.Styles.Normal.Render("listen"))
-	}
-
-	if m.showEstablished {
-		parts = append(parts, m.theme.Styles.Success.Render("estab"))
-	} else {
-		parts = append(parts, m.theme.Styles.Normal.Render("estab"))
-	}
-
-	if m.showOther {
-		parts = append(parts, m.theme.Styles.Success.Render("other"))
-	} else {
-		parts = append(parts, m.theme.Styles.Normal.Render("other"))
-	}
+	parts = append(parts, m.renderFilterLabel("l", "isten", m.showListening))
+	parts = append(parts, m.renderFilterLabel("e", "stab", m.showEstablished))
+	parts = append(parts, m.renderFilterLabel("o", "ther", m.showOther))
 
 	left := "  " + strings.Join(parts, "  ")
 
@@ -119,6 +98,18 @@ func (m model) renderTableHeader() string {
 	return m.theme.Styles.Header.Render(header) + "\n"
 }
 
+func (m model) renderFilterLabel(firstChar, rest string, active bool) string {
+	baseStyle := m.theme.Styles.Normal
+	if active {
+		baseStyle = m.theme.Styles.Success
+	}
+
+	underlinedFirst := baseStyle.Underline(true).Render(firstChar)
+	restPart := baseStyle.Render(rest)
+
+	return underlinedFirst + restPart
+}
+
 func (m model) renderSeparator() string {
 	w := m.width - 4
 	if w < 1 {
@@ -134,8 +125,11 @@ func (m model) renderConnections() string {
 	pageSize := m.pageSize()
 
 	if len(visible) == 0 {
-		empty := "\n  " + m.theme.Styles.Normal.Render("no connections match filters") + "\n"
-		return empty
+		b.WriteString("  " + m.theme.Styles.Normal.Render("no connections match filters") + "\n")
+		for i := 1; i < pageSize; i++ {
+			b.WriteString("\n")
+		}
+		return b.String()
 	}
 
 	start := m.scrollOffset(pageSize, len(visible))
@@ -169,19 +163,19 @@ func (m model) renderRow(c collector.Connection, selected bool) string {
 		process = SymbolDash
 	}
 
-	port := fmt.Sprintf("%d", c.Lport)
+	port := truncate(m.resolvePort(c.Lport, c.Proto), cols.port)
 	proto := c.Proto
 	state := c.State
 	if state == "" {
 		state = SymbolDash
 	}
 
-	local := c.Laddr
+	local := truncate(m.resolveAddr(c.Laddr), cols.local)
 	if local == "*" || local == "" {
 		local = "*"
 	}
 
-	remote := formatRemote(c.Raddr, c.Rport)
+	remote := truncate(m.formatRemote(c.Raddr, c.Rport, c.Proto), cols.remote)
 
 	// apply styling
 	protoStyled := m.theme.Styles.GetProtoStyle(proto).Render(fmt.Sprintf("%-*s", cols.proto, proto))
@@ -193,8 +187,8 @@ func (m model) renderRow(c collector.Connection, selected bool) string {
 		cols.port, port,
 		protoStyled,
 		stateStyled,
-		cols.local, truncate(local, cols.local),
-		truncate(remote, cols.remote))
+		cols.local, local,
+		remote)
 
 	if selected {
 		return m.theme.Styles.Selected.Render(row) + "\n"
@@ -209,7 +203,7 @@ func (m model) renderStatusLine() string {
 		return "  " + m.theme.Styles.Warning.Render(m.statusMessage)
 	}
 
-	left := "  " + m.theme.Styles.Normal.Render("t/u proto  l/e/o state  w watch  K kill  s sort  / search  ? help  q quit")
+	left := "  " + m.theme.Styles.Normal.Render("t/u proto  l/e/o state  n/N dns  w watch  K kill  s sort  / search  ? help  q quit")
 
 	// show watched count if any
 	if m.watchedCount() > 0 {
@@ -217,6 +211,21 @@ func (m model) renderStatusLine() string {
 		left += m.theme.Styles.Watched.Render(watchedInfo)
 	}
 
+	// show dns resolution status
+	var resolveStatus string
+	if m.resolveAddrs && m.resolvePorts {
+		resolveStatus = "all"
+	} else if m.resolveAddrs {
+		resolveStatus = "addrs"
+	} else if m.resolvePorts {
+		resolveStatus = "ports"
+	} else {
+		resolveStatus = "off"
+	}
+	if resolveStatus != "addrs" { // addrs is the default, don't show
+		left += m.theme.Styles.Normal.Render(fmt.Sprintf("  dns: %s", resolveStatus))
+	}
+
 	return left
 }
 
@@ -248,6 +257,11 @@ func (m model) renderHelp() string {
   s            cycle sort field
   S            reverse sort order
 
+  display
+  ───────
+  n            toggle address resolution (dns)
+  N            toggle port resolution (service names)
+
   process management
   ──────────────────
   w            watch/unwatch process (highlight & track)
@@ -277,6 +291,11 @@ func (m model) renderDetail() string {
 	b.WriteString("  " + m.theme.Styles.Header.Render("connection details") + "\n")
 	b.WriteString("  " + m.theme.Styles.Border.Render(strings.Repeat(BoxHorizontal, 40)) + "\n\n")
 
+	localAddr := m.resolveAddr(c.Laddr)
+	localPort := m.resolvePort(c.Lport, c.Proto)
+	remoteAddr := m.resolveAddr(c.Raddr)
+	remotePort := m.resolvePort(c.Rport, c.Proto)
+
 	fields := []struct {
 		label string
 		value string
@@ -286,8 +305,8 @@ func (m model) renderDetail() string {
 		{"user", c.User},
 		{"protocol", c.Proto},
 		{"state", c.State},
-		{"local", fmt.Sprintf("%s:%d", c.Laddr, c.Lport)},
-		{"remote", fmt.Sprintf("%s:%d", c.Raddr, c.Rport)},
+		{"local", fmt.Sprintf("%s:%s", localAddr, localPort)},
+		{"remote", fmt.Sprintf("%s:%s", remoteAddr, remotePort)},
 		{"interface", c.Interface},
 		{"inode", fmt.Sprintf("%d", c.Inode)},
 	}
@@ -506,23 +525,72 @@ type columns struct {
 }
 
 func (m model) columnWidths() columns {
-	available := m.safeWidth() - 16
-
+	// minimum widths (header lengths + padding)
 	c := columns{
-		process: 16,
-		port:    6,
-		proto:   5,
-		state:   11,
-		local:   15,
-		remote:  20,
+		process: 7,  // "PROCESS"
+		port:    4,  // "PORT"
+		proto:   5,  // "PROTO"
+		state:   5,  // "STATE"
+		local:   5,  // "LOCAL"
+		remote:  6,  // "REMOTE"
 	}
 
-	used := c.process + c.port + c.proto + c.state + c.local + c.remote
-	extra := available - used
+	// scan visible connections to find max content width for each column
+	visible := m.visibleConnections()
+	for _, conn := range visible {
+		if len(conn.Process) > c.process {
+			c.process = len(conn.Process)
+		}
 
-	if extra > 0 {
-		c.process += extra / 3
-		c.remote += extra - extra/3
+		port := m.resolvePort(conn.Lport, conn.Proto)
+		if len(port) > c.port {
+			c.port = len(port)
+		}
+
+		if len(conn.Proto) > c.proto {
+			c.proto = len(conn.Proto)
+		}
+
+		if len(conn.State) > c.state {
+			c.state = len(conn.State)
+		}
+
+		local := m.resolveAddr(conn.Laddr)
+		if len(local) > c.local {
+			c.local = len(local)
+		}
+
+		remote := m.formatRemote(conn.Raddr, conn.Rport, conn.Proto)
+		if len(remote) > c.remote {
+			c.remote = len(remote)
+		}
+	}
+
+	// calculate total and available width
+	spacing := 12 // 2 spaces between each of 6 columns
+	indicator := 2
+	margin := 2
+	available := m.safeWidth() - spacing - indicator - margin
+
+	total := c.process + c.port + c.proto + c.state + c.local + c.remote
+
+	// if content fits, we're done
+	if total <= available {
+		return c
+	}
+
+	// content exceeds available space - need to shrink columns proportionally
+	// fixed columns that shouldn't shrink much: port, proto, state
+	fixedWidth := c.port + c.proto + c.state
+	flexibleAvailable := available - fixedWidth
+
+	// distribute flexible space between process, local, remote
+	flexibleTotal := c.process + c.local + c.remote
+	if flexibleTotal > 0 && flexibleAvailable > 0 {
+		ratio := float64(flexibleAvailable) / float64(flexibleTotal)
+		c.process = max(7, int(float64(c.process)*ratio))
+		c.local = max(5, int(float64(c.local)*ratio))
+		c.remote = max(6, int(float64(c.remote)*ratio))
 	}
 
 	return c
@@ -544,3 +612,29 @@ func formatDuration(d time.Duration) string {
 	}
 	return fmt.Sprintf("%.0fm", d.Minutes())
 }
+
+func (m model) resolveAddr(addr string) string {
+	if !m.resolveAddrs {
+		return addr
+	}
+	if addr == "" || addr == "*" {
+		return addr
+	}
+	return resolver.ResolveAddr(addr)
+}
+
+func (m model) resolvePort(port int, proto string) string {
+	if !m.resolvePorts {
+		return strconv.Itoa(port)
+	}
+	return resolver.ResolvePort(port, proto)
+}
+
+func (m model) formatRemote(addr string, port int, proto string) string {
+	if addr == "" || addr == "*" || port == 0 {
+		return "-"
+	}
+	resolvedAddr := m.resolveAddr(addr)
+	resolvedPort := m.resolvePort(port, proto)
+	return fmt.Sprintf("%s:%s", resolvedAddr, resolvedPort)
+}

main.go

@@ -1,7 +1,7 @@
 package main
 
 import (
-	"snitch/cmd"
+	"github.com/karol-broda/snitch/cmd"
 )
 
 func main() {