add note about style env var in README

add 0.12.0 to CHANGELOG
fix --style shortname
2025-08-06 20:01:45 +00:00 · 2025-06-21 06:59:36 +01:00 · 2025-06-21 06:47:25 +01:00 · 2025-06-21 06:44:16 +01:00 · 2025-06-21 06:44:08 +01:00 · 2025-06-21 06:43:38 +01:00
29 changed files with 754 additions and 285 deletions
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@ -5,6 +5,21 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).

+# [0.12.0] - 2025-06-21
+
+### Added
+
+-   Various colouring styles, see [Style](https://github.com/onyx-and-iris/gobs-cli/tree/main?tab=readme-ov-file#style)
+    -   colouring is applied to list tables as well as highlighted information in stdout/stderr output.
+
+### Changed
+
+-   if an itemName is passed to a sceneitem command that's in a group, without the --group flag, a friendlier error message is displayed.
+    -   it will suggest using *gobs-cli si ls* to list sources in the scene.
+-   if an invalid --monitor-index is passed to projector open a friendlier error message is displayed.
+    -   it will suggest using *gobs-cli prj ls-m* to list available monitors.
+
+
 # [0.11.0] - 2025-06-20

 ### Added
--- a/README.md
+++ b/README.md
@ -606,6 +606,28 @@ gobs-cli projector open --monitor-index=1 "test_group"
 gobs-cli screenshot save --width=2560 --height=1440 "Scene" "C:\Users\me\Videos\screenshot.png"
 ```

+## Style
+
+By default styling is disabled but you may enable it with the --style/-s flag.
+
+Available options are:
+
+- red
+- magenta
+- purple
+- blue
+- cyan
+- green
+- yellow
+- orange
+- white
+- grey
+- navy
+- black
+
+Alternatively you may set the style with an environment variable `GOBS_STYLE`.
+

 [userconfigdir]: https://pkg.go.dev/os#UserConfigDir
 [obs-keyids]: https://github.com/obsproject/obs-studio/blob/master/libobs/obs-hotkeys.h
+[no-colour]: https://no-color.org/
--- a/filter.go
+++ b/filter.go
@ -7,7 +7,8 @@ import (
 	"strings"

 	"github.com/andreykaipov/goobs/api/requests/filters"
-	"github.com/aquasecurity/table"
+	"github.com/charmbracelet/lipgloss"
+	"github.com/charmbracelet/lipgloss/table"
 )

 // FilterCmd provides commands to manage filters in OBS Studio.
@ -25,6 +26,7 @@ type FilterListCmd struct {
 }

 // Run executes the command to list all filters in a scene.
+// nolint: misspell
 func (cmd *FilterListCmd) Run(ctx *context) error {
 	if cmd.SourceName == "" {
 		currentScene, err := ctx.Client.Scenes.GetCurrentProgramScene()
@ -42,14 +44,35 @@ func (cmd *FilterListCmd) Run(ctx *context) error {
 	}

 	if len(sourceFilters.Filters) == 0 {
-		fmt.Fprintf(ctx.Out, "No filters found for source %s.\n", cmd.SourceName)
+		fmt.Fprintf(ctx.Out, "No filters found for source %s.\n", ctx.Style.Highlight(cmd.SourceName))
 		return nil
 	}

-	t := table.New(ctx.Out)
-	t.SetPadding(3)
-	t.SetAlignment(table.AlignLeft, table.AlignLeft, table.AlignCenter, table.AlignLeft)
-	t.SetHeaders("Filter Name", "Kind", "Enabled", "Settings")
+	t := table.New().Border(lipgloss.RoundedBorder()).
+		BorderStyle(lipgloss.NewStyle().Foreground(ctx.Style.border)).
+		Headers("Filter Name", "Kind", "Enabled", "Settings").
+		StyleFunc(func(row, col int) lipgloss.Style {
+			style := lipgloss.NewStyle().Padding(0, 3)
+			switch col {
+			case 0:
+				style = style.Align(lipgloss.Left)
+			case 1:
+				style = style.Align(lipgloss.Left)
+			case 2:
+				style = style.Align(lipgloss.Center)
+			case 3:
+				style = style.Align(lipgloss.Left)
+			}
+			switch {
+			case row == table.HeaderRow:
+				style = style.Bold(true).Align(lipgloss.Center)
+			case row%2 == 0:
+				style = style.Foreground(ctx.Style.evenRows)
+			default:
+				style = style.Foreground(ctx.Style.oddRows)
+			}
+			return style
+		})

 	for _, filter := range sourceFilters.Filters {
 		defaultSettings, err := ctx.Client.Filters.GetSourceFilterDefaultSettings(
@ -58,7 +81,7 @@ func (cmd *FilterListCmd) Run(ctx *context) error {
 		)
 		if err != nil {
 			return fmt.Errorf("failed to get default settings for filter %s: %w",
-				filter.FilterName, err)
+				ctx.Style.Error(filter.FilterName), err)
 		}
 		maps.Insert(defaultSettings.DefaultFilterSettings, maps.All(filter.FilterSettings))

@ -70,14 +93,14 @@ func (cmd *FilterListCmd) Run(ctx *context) error {
 			return strings.ToLower(lines[i]) < strings.ToLower(lines[j])
 		})

-		t.AddRow(
+		t.Row(
 			filter.FilterName,
 			snakeCaseToTitleCase(filter.FilterKind),
 			getEnabledMark(filter.FilterEnabled),
 			strings.Join(lines, "\n"),
 		)
 	}
-	t.Render()
+	fmt.Fprintln(ctx.Out, t.Render())
 	return nil
 }

@ -97,10 +120,10 @@ func (cmd *FilterEnableCmd) Run(ctx *context) error {
 	)
 	if err != nil {
 		return fmt.Errorf("failed to enable filter %s on source %s: %w",
-			cmd.FilterName, cmd.SourceName, err)
+			ctx.Style.Error(cmd.FilterName), ctx.Style.Error(cmd.SourceName), err)
 	}
 	fmt.Fprintf(ctx.Out, "Filter %s enabled on source %s.\n",
-		cmd.FilterName, cmd.SourceName)
+		ctx.Style.Highlight(cmd.FilterName), ctx.Style.Highlight(cmd.SourceName))
 	return nil
 }

@ -120,10 +143,10 @@ func (cmd *FilterDisableCmd) Run(ctx *context) error {
 	)
 	if err != nil {
 		return fmt.Errorf("failed to disable filter %s on source %s: %w",
-			cmd.FilterName, cmd.SourceName, err)
+			ctx.Style.Error(cmd.FilterName), ctx.Style.Error(cmd.SourceName), err)
 	}
 	fmt.Fprintf(ctx.Out, "Filter %s disabled on source %s.\n",
-		cmd.FilterName, cmd.SourceName)
+		ctx.Style.Highlight(cmd.FilterName), ctx.Style.Highlight(cmd.SourceName))
 	return nil
 }

@ -142,7 +165,7 @@ func (cmd *FilterToggleCmd) Run(ctx *context) error {
 	)
 	if err != nil {
 		return fmt.Errorf("failed to get filter %s on source %s: %w",
-			cmd.FilterName, cmd.SourceName, err)
+			ctx.Style.Error(cmd.FilterName), ctx.Style.Error(cmd.SourceName), err)
 	}

 	newStatus := !filter.FilterEnabled
@ -154,15 +177,15 @@ func (cmd *FilterToggleCmd) Run(ctx *context) error {
 	)
 	if err != nil {
 		return fmt.Errorf("failed to toggle filter %s on source %s: %w",
-			cmd.FilterName, cmd.SourceName, err)
+			ctx.Style.Error(cmd.FilterName), ctx.Style.Error(cmd.SourceName), err)
 	}

 	if newStatus {
 		fmt.Fprintf(ctx.Out, "Filter %s on source %s is now enabled.\n",
-			cmd.FilterName, cmd.SourceName)
+			ctx.Style.Highlight(cmd.FilterName), ctx.Style.Highlight(cmd.SourceName))
 	} else {
 		fmt.Fprintf(ctx.Out, "Filter %s on source %s is now disabled.\n",
-			cmd.FilterName, cmd.SourceName)
+			ctx.Style.Highlight(cmd.FilterName), ctx.Style.Highlight(cmd.SourceName))
 	}
 	return nil
 }
@ -182,14 +205,14 @@ func (cmd *FilterStatusCmd) Run(ctx *context) error {
 	)
 	if err != nil {
 		return fmt.Errorf("failed to get status of filter %s on source %s: %w",
-			cmd.FilterName, cmd.SourceName, err)
+			ctx.Style.Error(cmd.FilterName), ctx.Style.Error(cmd.SourceName), err)
 	}
 	if filter.FilterEnabled {
 		fmt.Fprintf(ctx.Out, "Filter %s on source %s is enabled.\n",
-			cmd.FilterName, cmd.SourceName)
+			ctx.Style.Highlight(cmd.FilterName), ctx.Style.Highlight(cmd.SourceName))
 	} else {
 		fmt.Fprintf(ctx.Out, "Filter %s on source %s is disabled.\n",
-			cmd.FilterName, cmd.SourceName)
+			ctx.Style.Highlight(cmd.FilterName), ctx.Style.Highlight(cmd.SourceName))
 	}
 	return nil
 }
--- a/filter_test.go
+++ b/filter_test.go
@ -11,10 +11,7 @@ func TestFilterList(t *testing.T) {
 	defer disconnect()

 	var out bytes.Buffer
-	context := &context{
-		Client: client,
-		Out:    &out,
-	}
+	context := newContext(client, &out, "")

 	cmd := &FilterListCmd{
 		SourceName: "Mic/Aux",
@ -33,10 +30,7 @@ func TestFilterListScene(t *testing.T) {
 	defer disconnect()

 	var out bytes.Buffer
-	context := &context{
-		Client: client,
-		Out:    &out,
-	}
+	context := newContext(client, &out, "")

 	cmd := &FilterListCmd{
 		SourceName: "gobs-test",
@ -55,10 +49,7 @@ func TestFilterListEmpty(t *testing.T) {
 	defer disconnect()

 	var out bytes.Buffer
-	context := &context{
-		Client: client,
-		Out:    &out,
-	}
+	context := newContext(client, &out, "")

 	cmd := &FilterListCmd{
 		SourceName: "NonExistentSource",
--- a/go.mod
+++ b/go.mod
@ -6,22 +6,30 @@ require (
 	github.com/alecthomas/kong v1.10.0
 	github.com/alecthomas/mango-kong v0.1.0
 	github.com/andreykaipov/goobs v1.5.6
-	github.com/aquasecurity/table v1.10.0
+	github.com/charmbracelet/lipgloss v1.1.0
 	github.com/titusjaka/kong-dotenv-go v0.1.0
 )

 require (
+	github.com/aymanbagabas/go-osc52/v2 v2.0.1 // indirect
 	github.com/buger/jsonparser v1.1.1 // indirect
+	github.com/charmbracelet/colorprofile v0.2.3-0.20250311203215-f60798e515dc // indirect
+	github.com/charmbracelet/x/ansi v0.8.0 // indirect
+	github.com/charmbracelet/x/cellbuf v0.0.13-0.20250311204145-2c3ea96c31dd // indirect
+	github.com/charmbracelet/x/term v0.2.1 // indirect
 	github.com/gorilla/websocket v1.5.3 // indirect
 	github.com/hashicorp/logutils v1.0.0 // indirect
 	github.com/joho/godotenv v1.5.1 // indirect
-	github.com/mattn/go-runewidth v0.0.13 // indirect
+	github.com/lucasb-eyer/go-colorful v1.2.0 // indirect
+	github.com/mattn/go-isatty v0.0.20 // indirect
+	github.com/mattn/go-runewidth v0.0.16 // indirect
 	github.com/mitchellh/mapstructure v1.5.0 // indirect
 	github.com/mmcloughlin/profile v0.1.1 // indirect
 	github.com/muesli/mango v0.1.1-0.20220205060214-77e2058169ab // indirect
 	github.com/muesli/roff v0.1.0 // indirect
+	github.com/muesli/termenv v0.16.0 // indirect
 	github.com/nu7hatch/gouuid v0.0.0-20131221200532-179d4d0c4d8d // indirect
-	github.com/rivo/uniseg v0.2.0 // indirect
-	golang.org/x/sys v0.1.0 // indirect
-	golang.org/x/term v0.0.0-20220526004731-065cf7ba2467 // indirect
+	github.com/rivo/uniseg v0.4.7 // indirect
+	github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e // indirect
+	golang.org/x/sys v0.30.0 // indirect
 )
--- a/go.sum
+++ b/go.sum
@ -8,10 +8,24 @@ github.com/alecthomas/repr v0.4.0 h1:GhI2A8MACjfegCPVq9f1FLvIBS+DrQ2KQBFZP1iFzXc
 github.com/alecthomas/repr v0.4.0/go.mod h1:Fr0507jx4eOXV7AlPV6AVZLYrLIuIeSOWtW57eE/O/4=
 github.com/andreykaipov/goobs v1.5.6 h1:eIkEqYN99+2VJvmlY/56Ah60nkRKS6efMQvpM3oUgPQ=
 github.com/andreykaipov/goobs v1.5.6/go.mod h1:iSZP93FJ4d9X/U1x4DD4IyILLtig+vViqZWBGjLywcY=
-github.com/aquasecurity/table v1.10.0 h1:gPWV28qp9XSlvXdT3ku8yKQoZE6II0vsmegKpW+dB08=
-github.com/aquasecurity/table v1.10.0/go.mod h1:eqOmvjjB7AhXFgFqpJUEE/ietg7RrMSJZXyTN8E/wZw=
+github.com/aymanbagabas/go-osc52/v2 v2.0.1 h1:HwpRHbFMcZLEVr42D4p7XBqjyuxQH5SMiErDT4WkJ2k=
+github.com/aymanbagabas/go-osc52/v2 v2.0.1/go.mod h1:uYgXzlJ7ZpABp8OJ+exZzJJhRNQ2ASbcXHWsFqH8hp8=
+github.com/aymanbagabas/go-udiff v0.2.0 h1:TK0fH4MteXUDspT88n8CKzvK0X9O2xu9yQjWpi6yML8=
+github.com/aymanbagabas/go-udiff v0.2.0/go.mod h1:RE4Ex0qsGkTAJoQdQQCA0uG+nAzJO/pI/QwceO5fgrA=
 github.com/buger/jsonparser v1.1.1 h1:2PnMjfWD7wBILjqQbt530v576A/cAbQvEW9gGIpYMUs=
 github.com/buger/jsonparser v1.1.1/go.mod h1:6RYKKt7H4d4+iWqouImQ9R2FZql3VbhNgx27UK13J/0=
+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/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.8.0 h1:9GTq3xq9caJW8ZrBTe0LIe2fvfLR/bYXKTx2llXn7xE=
+github.com/charmbracelet/x/ansi v0.8.0/go.mod h1:wdYl/ONOLHLIVmQaxbIYEC/cRKOQyjTkowiI4blgS9Q=
+github.com/charmbracelet/x/cellbuf v0.0.13-0.20250311204145-2c3ea96c31dd h1:vy0GVL4jeHEwG5YOXDmi86oYw2yuYUGqz6a8sLwg0X8=
+github.com/charmbracelet/x/cellbuf v0.0.13-0.20250311204145-2c3ea96c31dd/go.mod h1:xe0nKWGd3eJgtqZRaN9RjMtK7xUYchjzPr7q6kcvCCs=
+github.com/charmbracelet/x/exp/golden v0.0.0-20240806155701-69247e0abc2a h1:G99klV19u0QnhiizODirwVksQB91TJKV/UaTnACcG30=
+github.com/charmbracelet/x/exp/golden v0.0.0-20240806155701-69247e0abc2a/go.mod h1:wDlXFlCrmJ8J+swcL/MnGUuYnqgQdW9rhSD61oNMb6U=
+github.com/charmbracelet/x/term v0.2.1 h1:AQeHeLZ1OqSXhrAWpYUtZyX1T3zVxfpZuEQMIQaGIAQ=
+github.com/charmbracelet/x/term v0.2.1/go.mod h1:oQ4enTYFV7QN4m0i9mzHrViD7TQKvNEEkHUMCmsxdUg=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/gorilla/websocket v1.5.3 h1:saDtZ6Pbx/0u+bgYQ3q96pZgCzfhKXGPqt7kZ72aNNg=
@ -22,8 +36,12 @@ github.com/hexops/gotextdiff v1.0.3 h1:gitA9+qJrrTCsiCl7+kh75nPqQt1cx4ZkudSTLoUq
 github.com/hexops/gotextdiff v1.0.3/go.mod h1:pSWU5MAI3yDq+fZBTazCSJysOMbxWL1BSow5/V2vxeg=
 github.com/joho/godotenv v1.5.1 h1:7eLL/+HRGLY0ldzfGMeQkb7vMd0as4CfYvUVzLqw0N0=
 github.com/joho/godotenv v1.5.1/go.mod h1:f4LDr5Voq0i2e/R5DDNOoa2zzDfwtkZa6DnEwAbqwq4=
-github.com/mattn/go-runewidth v0.0.13 h1:lTGmDsbAYt5DmK6OnoV7EuIF1wEIFAcxld6ypU4OSgU=
-github.com/mattn/go-runewidth v0.0.13/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
+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/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
+github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
+github.com/mattn/go-runewidth v0.0.16 h1:E5ScNMtiwvlvB5paMFdw9p4kSQzbXFikJ5SQO6TULQc=
+github.com/mattn/go-runewidth v0.0.16/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
 github.com/mitchellh/mapstructure v1.5.0 h1:jeMsZIYE/09sWLaz43PL7Gy6RuMjD2eJVyuac5Z2hdY=
 github.com/mitchellh/mapstructure v1.5.0/go.mod h1:bFUtVrKA4DC2yAKiSyO/QUcy7e+RRV2QTWOzhPopBRo=
 github.com/mmcloughlin/profile v0.1.1 h1:jhDmAqPyebOsVDOCICJoINoLb/AnLBaUw58nFzxWS2w=
@ -32,19 +50,25 @@ github.com/muesli/mango v0.1.1-0.20220205060214-77e2058169ab h1:m7QFONkzLK0fVXCj
 github.com/muesli/mango v0.1.1-0.20220205060214-77e2058169ab/go.mod h1:5XFpbC8jY5UUv89YQciiXNlbi+iJgt29VDC5xbzrLL4=
 github.com/muesli/roff v0.1.0 h1:YD0lalCotmYuF5HhZliKWlIx7IEhiXeSfq7hNjFqGF8=
 github.com/muesli/roff v0.1.0/go.mod h1:pjAHQM9hdUUwm/krAfrLGgJkXJ+YuhtsfZ42kieB2Ig=
+github.com/muesli/termenv v0.16.0 h1:S5AlUN9dENB57rsbnkPyfdGuWIlkmzJjbFf0Tf5FWUc=
+github.com/muesli/termenv v0.16.0/go.mod h1:ZRfOIKPFDYQoDFF4Olj7/QJbW60Ol/kL1pU3VfY/Cnk=
 github.com/nu7hatch/gouuid v0.0.0-20131221200532-179d4d0c4d8d h1:VhgPp6v9qf9Agr/56bj7Y/xa04UccTW04VP0Qed4vnQ=
 github.com/nu7hatch/gouuid v0.0.0-20131221200532-179d4d0c4d8d/go.mod h1:YUTz3bUH2ZwIWBy3CJBeOBEugqcmXREj14T+iG/4k4U=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-github.com/rivo/uniseg v0.2.0 h1:S1pD9weZBuJdFmowNwbpi7BJ8TNftyUImj/0WQi72jY=
 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/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=
 github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
 github.com/titusjaka/kong-dotenv-go v0.1.0 h1:TmUjP/sXoNiKLr6oR7n9xrB5XyXi/Ssuebzfz5nxZj4=
 github.com/titusjaka/kong-dotenv-go v0.1.0/go.mod h1:pBgLjcu82oqUgb7+bngK9+Ch7jg49E0YADP8Wnj2MXU=
-golang.org/x/sys v0.1.0 h1:kunALQeHf1/185U1i0GOB/fy1IPRDDpuoOOqRReG57U=
-golang.org/x/sys v0.1.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/term v0.0.0-20220526004731-065cf7ba2467 h1:CBpWXWQpIRjzmkkA+M7q9Fqnwd2mZr3AFqexg8YTfoM=
-golang.org/x/term v0.0.0-20220526004731-065cf7ba2467/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
+github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e h1:JVG44RsyaB9T2KIHavMF/ppJZNG9ZpyihvCd0w101no=
+github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e/go.mod h1:RbqR21r5mrJuqunuUZ/Dhy/avygyECGrLceyNeo4LiM=
+golang.org/x/exp v0.0.0-20220909182711-5c715a9e8561 h1:MDc5xs78ZrZr3HMQugiXOAkSZtfTpbJLDr/lwfgO53E=
+golang.org/x/exp v0.0.0-20220909182711-5c715a9e8561/go.mod h1:cyybsKvd6eL0RnXn6p/Grxp8F5bW7iYuBgsNCOHpMYE=
+golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.30.0 h1:QjkSwP/36a20jFYWkSue1YwXzLmsV5Gfq7Eiy72C1uc=
+golang.org/x/sys v0.30.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
--- a/group.go
+++ b/group.go
@ -4,7 +4,8 @@ import (
 	"fmt"

 	"github.com/andreykaipov/goobs/api/requests/sceneitems"
-	"github.com/aquasecurity/table"
+	"github.com/charmbracelet/lipgloss"
+	"github.com/charmbracelet/lipgloss/table"
 )

 // GroupCmd provides commands to manage groups in OBS Studio.
@ -22,6 +23,7 @@ type GroupListCmd struct {
 }

 // Run executes the command to list all groups in a scene.
+// nolint: misspell
 func (cmd *GroupListCmd) Run(ctx *context) error {
 	if cmd.SceneName == "" {
 		currentScene, err := ctx.Client.Scenes.GetCurrentProgramScene()
@ -37,17 +39,44 @@ func (cmd *GroupListCmd) Run(ctx *context) error {
 		return fmt.Errorf("failed to get scene item list: %w", err)
 	}

-	t := table.New(ctx.Out)
-	t.SetPadding(3)
-	t.SetAlignment(table.AlignCenter, table.AlignLeft, table.AlignCenter)
-	t.SetHeaders("ID", "Group Name", "Enabled")
+	t := table.New().Border(lipgloss.RoundedBorder()).
+		BorderStyle(lipgloss.NewStyle().Foreground(ctx.Style.border)).
+		Headers("ID", "Group Name", "Enabled").
+		StyleFunc(func(row, col int) lipgloss.Style {
+			style := lipgloss.NewStyle().Padding(0, 3)
+			switch col {
+			case 0:
+				style = style.Align(lipgloss.Center)
+			case 1:
+				style = style.Align(lipgloss.Left)
+			case 2:
+				style = style.Align(lipgloss.Center)
+			}
+			switch {
+			case row == table.HeaderRow:
+				style = style.Bold(true).Align(lipgloss.Center)
+			case row%2 == 0:
+				style = style.Foreground(ctx.Style.evenRows)
+			default:
+				style = style.Foreground(ctx.Style.oddRows)
+			}
+			return style
+		})

+	var found bool
 	for _, item := range resp.SceneItems {
 		if item.IsGroup {
-			t.AddRow(fmt.Sprintf("%d", item.SceneItemID), item.SourceName, getEnabledMark(item.SceneItemEnabled))
+			t.Row(fmt.Sprintf("%d", item.SceneItemID), item.SourceName, getEnabledMark(item.SceneItemEnabled))
+			found = true
 		}
 	}
-	t.Render()
+
+	if !found {
+		fmt.Fprintf(ctx.Out, "No groups found in scene %s.\n", ctx.Style.Highlight(cmd.SceneName))
+		return nil
+	}
+
+	fmt.Fprintln(ctx.Out, t.Render())
 	return nil
 }

@ -75,13 +104,17 @@ func (cmd *GroupShowCmd) Run(ctx *context) error {
 			if err != nil {
 				return fmt.Errorf("failed to set scene item enabled: %w", err)
 			}
-			fmt.Fprintf(ctx.Out, "Group %s is now shown.\n", cmd.GroupName)
+			fmt.Fprintf(ctx.Out, "Group %s is now shown.\n", ctx.Style.Highlight(cmd.GroupName))
 			found = true
 			break
 		}
 	}
 	if !found {
-		return fmt.Errorf("group '%s' not found", cmd.GroupName)
+		return fmt.Errorf(
+			"group %s not found in scene %s",
+			ctx.Style.Error(cmd.GroupName),
+			ctx.Style.Error(cmd.SceneName),
+		)
 	}
 	return nil
 }
@ -110,13 +143,17 @@ func (cmd *GroupHideCmd) Run(ctx *context) error {
 			if err != nil {
 				return fmt.Errorf("failed to set scene item enabled: %w", err)
 			}
-			fmt.Fprintf(ctx.Out, "Group %s is now hidden.\n", cmd.GroupName)
+			fmt.Fprintf(ctx.Out, "Group %s is now hidden.\n", ctx.Style.Highlight(cmd.GroupName))
 			found = true
 			break
 		}
 	}
 	if !found {
-		return fmt.Errorf("group '%s' not found", cmd.GroupName)
+		return fmt.Errorf(
+			"group %s not found in scene %s",
+			ctx.Style.Error(cmd.GroupName),
+			ctx.Style.Error(cmd.SceneName),
+		)
 	}
 	return nil
 }
@ -147,16 +184,20 @@ func (cmd *GroupToggleCmd) Run(ctx *context) error {
 				return fmt.Errorf("failed to set scene item enabled: %w", err)
 			}
 			if newState {
-				fmt.Fprintf(ctx.Out, "Group %s is now shown.\n", cmd.GroupName)
+				fmt.Fprintf(ctx.Out, "Group %s is now shown.\n", ctx.Style.Highlight(cmd.GroupName))
 			} else {
-				fmt.Fprintf(ctx.Out, "Group %s is now hidden.\n", cmd.GroupName)
+				fmt.Fprintf(ctx.Out, "Group %s is now hidden.\n", ctx.Style.Highlight(cmd.GroupName))
 			}
 			found = true
 			break
 		}
 	}
 	if !found {
-		return fmt.Errorf("group '%s' not found", cmd.GroupName)
+		return fmt.Errorf(
+			"group %s not found in scene %s",
+			ctx.Style.Error(cmd.GroupName),
+			ctx.Style.Error(cmd.SceneName),
+		)
 	}

 	return nil
@ -178,12 +219,12 @@ func (cmd *GroupStatusCmd) Run(ctx *context) error {
 	for _, item := range resp.SceneItems {
 		if item.IsGroup && item.SourceName == cmd.GroupName {
 			if item.SceneItemEnabled {
-				fmt.Fprintf(ctx.Out, "Group %s is shown.\n", cmd.GroupName)
+				fmt.Fprintf(ctx.Out, "Group %s is shown.\n", ctx.Style.Highlight(cmd.GroupName))
 			} else {
-				fmt.Fprintf(ctx.Out, "Group %s is hidden.\n", cmd.GroupName)
+				fmt.Fprintf(ctx.Out, "Group %s is hidden.\n", ctx.Style.Highlight(cmd.GroupName))
 			}
 			return nil
 		}
 	}
-	return fmt.Errorf("group '%s' not found", cmd.GroupName)
+	return fmt.Errorf("group %s not found in scene %s", ctx.Style.Error(cmd.GroupName), ctx.Style.Error(cmd.SceneName))
 }
--- a/group_test.go
+++ b/group_test.go
@ -11,10 +11,7 @@ func TestGroupList(t *testing.T) {
 	defer disconnect()

 	var out bytes.Buffer
-	context := &context{
-		Client: client,
-		Out:    &out,
-	}
+	context := newContext(client, &out, "")

 	cmd := &GroupListCmd{
 		SceneName: "Scene",
@ -33,10 +30,7 @@ func TestGroupShow(t *testing.T) {
 	defer disconnect()

 	var out bytes.Buffer
-	context := &context{
-		Client: client,
-		Out:    &out,
-	}
+	context := newContext(client, &out, "")

 	cmd := &GroupShowCmd{
 		SceneName: "Scene",
@ -56,10 +50,7 @@ func TestGroupToggle(t *testing.T) {
 	defer disconnect()

 	var out bytes.Buffer
-	context := &context{
-		Client: client,
-		Out:    &out,
-	}
+	context := newContext(client, &out, "")

 	cmdStatus := &GroupStatusCmd{
 		SceneName: "Scene",
@ -100,10 +91,7 @@ func TestGroupStatus(t *testing.T) {
 	defer disconnect()

 	var out bytes.Buffer
-	context := &context{
-		Client: client,
-		Out:    &out,
-	}
+	context := newContext(client, &out, "")

 	cmdShow := &GroupShowCmd{
 		SceneName: "Scene",
--- a/hotkey.go
+++ b/hotkey.go
@ -1,9 +1,12 @@
 package main

 import (
+	"fmt"
+
 	"github.com/andreykaipov/goobs/api/requests/general"
 	"github.com/andreykaipov/goobs/api/typedefs"
-	"github.com/aquasecurity/table"
+	"github.com/charmbracelet/lipgloss"
+	"github.com/charmbracelet/lipgloss/table"
 )

 // HotkeyCmd provides commands to manage hotkeys in OBS Studio.
@ -23,15 +26,26 @@ func (cmd *HotkeyListCmd) Run(ctx *context) error {
 		return err
 	}

-	t := table.New(ctx.Out)
-	t.SetPadding(3)
-	t.SetAlignment(table.AlignLeft)
-	t.SetHeaders("Hotkey Name")
+	t := table.New().Border(lipgloss.RoundedBorder()).
+		BorderStyle(lipgloss.NewStyle().Foreground(ctx.Style.border)).
+		Headers("Hotkey Name").
+		StyleFunc(func(row, _ int) lipgloss.Style {
+			style := lipgloss.NewStyle().Padding(0, 3)
+			switch {
+			case row == table.HeaderRow:
+				style = style.Bold(true).Align(lipgloss.Center) // nolint: misspell
+			case row%2 == 0:
+				style = style.Foreground(ctx.Style.evenRows)
+			default:
+				style = style.Foreground(ctx.Style.oddRows)
+			}
+			return style
+		})

 	for _, hotkey := range resp.Hotkeys {
-		t.AddRow(hotkey)
+		t.Row(hotkey)
 	}
-	t.Render()
+	fmt.Fprintln(ctx.Out, t.Render())
 	return nil
 }

--- a/input.go
+++ b/input.go
@ -1,3 +1,4 @@
+// nolint: misspell
 package main

 import (
@ -6,7 +7,8 @@ import (
 	"strings"

 	"github.com/andreykaipov/goobs/api/requests/inputs"
-	"github.com/aquasecurity/table"
+	"github.com/charmbracelet/lipgloss"
+	"github.com/charmbracelet/lipgloss/table"
 )

 // InputCmd provides commands to manage inputs in OBS Studio.
@ -34,15 +36,35 @@ func (cmd *InputListCmd) Run(ctx *context) error {
 		return err
 	}

-	t := table.New(ctx.Out)
-	t.SetPadding(3)
+	t := table.New().Border(lipgloss.RoundedBorder()).
+		BorderStyle(lipgloss.NewStyle().Foreground(ctx.Style.border))
 	if cmd.UUID {
-		t.SetAlignment(table.AlignLeft, table.AlignLeft, table.AlignCenter, table.AlignLeft)
-		t.SetHeaders("Input Name", "Kind", "Muted", "UUID")
+		t.Headers("Input Name", "Kind", "Muted", "UUID")
 	} else {
-		t.SetAlignment(table.AlignLeft, table.AlignLeft, table.AlignCenter)
-		t.SetHeaders("Input Name", "Kind", "Muted")
+		t.Headers("Input Name", "Kind", "Muted")
 	}
+	t.StyleFunc(func(row, col int) lipgloss.Style {
+		style := lipgloss.NewStyle().Padding(0, 3)
+		switch col {
+		case 0:
+			style = style.Align(lipgloss.Left)
+		case 1:
+			style = style.Align(lipgloss.Left)
+		case 2:
+			style = style.Align(lipgloss.Center)
+		case 3:
+			style = style.Align(lipgloss.Left)
+		}
+		switch {
+		case row == table.HeaderRow:
+			style = style.Bold(true).Align(lipgloss.Center)
+		case row%2 == 0:
+			style = style.Foreground(ctx.Style.evenRows)
+		default:
+			style = style.Foreground(ctx.Style.oddRows)
+		}
+		return style
+	})

 	sort.Slice(resp.Inputs, func(i, j int) bool {
 		return resp.Inputs[i].InputName < resp.Inputs[j].InputName
@ -79,9 +101,9 @@ func (cmd *InputListCmd) Run(ctx *context) error {
 		for _, f := range filters {
 			if f.enabled && strings.Contains(input.InputKind, f.keyword) {
 				if cmd.UUID {
-					t.AddRow(input.InputName, input.InputKind, muteMark, input.InputUuid)
+					t.Row(input.InputName, input.InputKind, muteMark, input.InputUuid)
 				} else {
-					t.AddRow(input.InputName, input.InputKind, muteMark)
+					t.Row(input.InputName, input.InputKind, muteMark)
 				}
 				added = true
 				break
@ -90,13 +112,13 @@ func (cmd *InputListCmd) Run(ctx *context) error {

 		if !added && (!cmd.Input && !cmd.Output && !cmd.Colour && !cmd.Ffmpeg && !cmd.Vlc) {
 			if cmd.UUID {
-				t.AddRow(input.InputName, snakeCaseToTitleCase(input.InputKind), muteMark, input.InputUuid)
+				t.Row(input.InputName, snakeCaseToTitleCase(input.InputKind), muteMark, input.InputUuid)
 			} else {
-				t.AddRow(input.InputName, snakeCaseToTitleCase(input.InputKind), muteMark)
+				t.Row(input.InputName, snakeCaseToTitleCase(input.InputKind), muteMark)
 			}
 		}
 	}
-	t.Render()
+	fmt.Fprintln(ctx.Out, t.Render())
 	return nil
 }

@ -114,7 +136,7 @@ func (cmd *InputMuteCmd) Run(ctx *context) error {
 		return fmt.Errorf("failed to mute input: %w", err)
 	}

-	fmt.Fprintf(ctx.Out, "Muted input: %s\n", cmd.InputName)
+	fmt.Fprintf(ctx.Out, "Muted input: %s\n", ctx.Style.Highlight(cmd.InputName))
 	return nil
 }

@ -132,7 +154,7 @@ func (cmd *InputUnmuteCmd) Run(ctx *context) error {
 		return fmt.Errorf("failed to unmute input: %w", err)
 	}

-	fmt.Fprintf(ctx.Out, "Unmuted input: %s\n", cmd.InputName)
+	fmt.Fprintf(ctx.Out, "Unmuted input: %s\n", ctx.Style.Highlight(cmd.InputName))
 	return nil
 }

@ -160,9 +182,9 @@ func (cmd *InputToggleCmd) Run(ctx *context) error {
 	}

 	if newMuteState {
-		fmt.Fprintf(ctx.Out, "Muted input: %s\n", cmd.InputName)
+		fmt.Fprintf(ctx.Out, "Muted input: %s\n", ctx.Style.Highlight(cmd.InputName))
 	} else {
-		fmt.Fprintf(ctx.Out, "Unmuted input: %s\n", cmd.InputName)
+		fmt.Fprintf(ctx.Out, "Unmuted input: %s\n", ctx.Style.Highlight(cmd.InputName))
 	}
 	return nil
 }
--- a/input_test.go
+++ b/input_test.go
@ -11,10 +11,7 @@ func TestInputList(t *testing.T) {
 	defer disconnect()

 	var out bytes.Buffer
-	context := &context{
-		Client: client,
-		Out:    &out,
-	}
+	context := newContext(client, &out, "")

 	cmd := &InputListCmd{}
 	err := cmd.Run(context)
@ -42,10 +39,7 @@ func TestInputListFilterInput(t *testing.T) {
 	defer disconnect()

 	var out bytes.Buffer
-	context := &context{
-		Client: client,
-		Out:    &out,
-	}
+	context := newContext(client, &out, "")

 	cmd := &InputListCmd{Input: true}
 	err := cmd.Run(context)
@ -79,10 +73,7 @@ func TestInputListFilterOutput(t *testing.T) {
 	defer disconnect()

 	var out bytes.Buffer
-	context := &context{
-		Client: client,
-		Out:    &out,
-	}
+	context := newContext(client, &out, "")

 	cmd := &InputListCmd{Output: true}
 	err := cmd.Run(context)
@ -116,10 +107,7 @@ func TestInputListFilterColour(t *testing.T) {
 	defer disconnect()

 	var out bytes.Buffer
-	context := &context{
-		Client: client,
-		Out:    &out,
-	}
+	context := newContext(client, &out, "")

 	cmd := &InputListCmd{Colour: true}
 	err := cmd.Run(context)
--- a/main.go
+++ b/main.go
@ -24,10 +24,16 @@ type ObsConfig struct {
 	Timeout  int    `flag:"timeout"  help:"Timeout in seconds."          default:"5"         env:"OBS_TIMEOUT"  short:"T"`
 }

+// StyleConfig holds the configuration for styling the CLI output.
+type StyleConfig struct {
+	Style string `help:"Style used in output." flag:"style" default:"" env:"GOBS_STYLE" short:"s" enum:",red,magenta,purple,blue,cyan,green,yellow,orange,white,grey,navy,black"`
+}
+
 // CLI is the main command line interface structure.
 // It embeds the ObsConfig struct to inherit its fields and flags.
 type CLI struct {
 	ObsConfig   `embed:"" help:"OBS WebSocket configuration."`
+	StyleConfig `embed:"" help:"Style configuration."`

 	Man     mangokong.ManFlag `help:"Print man page."`
 	Version VersionFlag       `help:"Print gobs-cli version information and quit" name:"version" short:"v"`
@ -53,6 +59,15 @@ type CLI struct {
 type context struct {
 	Client *goobs.Client
 	Out    io.Writer
+	Style  *Style
+}
+
+func newContext(client *goobs.Client, out io.Writer, styleName string) *context {
+	return &context{
+		Client: client,
+		Out:    out,
+		Style:  styleFromFlag(styleName),
+	}
 }

 func main() {
@ -73,10 +88,7 @@ func main() {
 	client, err := connectObs(cli.ObsConfig)
 	ctx.FatalIfErrorf(err)

-	ctx.Bind(&context{
-		Client: client,
-		Out:    os.Stdout,
-	})
+	ctx.Bind(newContext(client, os.Stdout, cli.StyleConfig.Style))

 	ctx.FatalIfErrorf(run(ctx, client))
 }
--- a/profile.go
+++ b/profile.go
@ -5,7 +5,8 @@ import (
 	"slices"

 	"github.com/andreykaipov/goobs/api/requests/config"
-	"github.com/aquasecurity/table"
+	"github.com/charmbracelet/lipgloss"
+	"github.com/charmbracelet/lipgloss/table"
 )

 // ProfileCmd provides commands to manage profiles in OBS Studio.
@ -21,16 +22,34 @@ type ProfileCmd struct {
 type ProfileListCmd struct{} // size = 0x0

 // Run executes the command to list all profiles.
+// nolint: misspell
 func (cmd *ProfileListCmd) Run(ctx *context) error {
 	profiles, err := ctx.Client.Config.GetProfileList()
 	if err != nil {
 		return err
 	}

-	t := table.New(ctx.Out)
-	t.SetPadding(3)
-	t.SetAlignment(table.AlignLeft, table.AlignCenter)
-	t.SetHeaders("Profile Name", "Current")
+	t := table.New().Border(lipgloss.RoundedBorder()).
+		BorderStyle(lipgloss.NewStyle().Foreground(ctx.Style.border)).
+		Headers("Profile Name", "Current").
+		StyleFunc(func(row, col int) lipgloss.Style {
+			style := lipgloss.NewStyle().Padding(0, 3)
+			switch col {
+			case 0:
+				style = style.Align(lipgloss.Left)
+			case 1:
+				style = style.Align(lipgloss.Center)
+			}
+			switch {
+			case row == table.HeaderRow:
+				style = style.Bold(true).Align(lipgloss.Center)
+			case row%2 == 0:
+				style = style.Foreground(ctx.Style.evenRows)
+			default:
+				style = style.Foreground(ctx.Style.oddRows)
+			}
+			return style
+		})

 	for _, profile := range profiles.Profiles {
 		var enabledMark string
@ -38,9 +57,9 @@ func (cmd *ProfileListCmd) Run(ctx *context) error {
 			enabledMark = getEnabledMark(true)
 		}

-		t.AddRow(profile, enabledMark)
+		t.Row(profile, enabledMark)
 	}
-	t.Render()
+	fmt.Fprintln(ctx.Out, t.Render())
 	return nil
 }

@ -53,7 +72,7 @@ func (cmd *ProfileCurrentCmd) Run(ctx *context) error {
 	if err != nil {
 		return err
 	}
-	fmt.Fprintf(ctx.Out, "Current profile: %s\n", profiles.CurrentProfileName)
+	fmt.Fprintf(ctx.Out, "Current profile: %s\n", ctx.Style.Highlight(profiles.CurrentProfileName))

 	return nil
 }
@ -72,15 +91,20 @@ func (cmd *ProfileSwitchCmd) Run(ctx *context) error {
 	current := profiles.CurrentProfileName

 	if current == cmd.Name {
-		return nil
+		return fmt.Errorf("already using profile %s", ctx.Style.Error(cmd.Name))
 	}

 	_, err = ctx.Client.Config.SetCurrentProfile(config.NewSetCurrentProfileParams().WithProfileName(cmd.Name))
 	if err != nil {
-		return err
+		return fmt.Errorf("failed to switch to profile %s: %w", ctx.Style.Error(cmd.Name), err)
 	}

-	fmt.Fprintf(ctx.Out, "Switched from profile %s to %s\n", current, cmd.Name)
+	fmt.Fprintf(
+		ctx.Out,
+		"Switched from profile %s to %s\n",
+		ctx.Style.Highlight(current),
+		ctx.Style.Highlight(cmd.Name),
+	)

 	return nil
 }
@ -98,15 +122,15 @@ func (cmd *ProfileCreateCmd) Run(ctx *context) error {
 	}

 	if slices.Contains(profiles.Profiles, cmd.Name) {
-		return fmt.Errorf("profile %s already exists", cmd.Name)
+		return fmt.Errorf("profile %s already exists", ctx.Style.Error(cmd.Name))
 	}

 	_, err = ctx.Client.Config.CreateProfile(config.NewCreateProfileParams().WithProfileName(cmd.Name))
 	if err != nil {
-		return err
+		return fmt.Errorf("failed to create profile %s: %w", ctx.Style.Error(cmd.Name), err)
 	}

-	fmt.Fprintf(ctx.Out, "Created profile: %s\n", cmd.Name)
+	fmt.Fprintf(ctx.Out, "Created profile: %s\n", ctx.Style.Highlight(cmd.Name))

 	return nil
 }
@ -124,19 +148,21 @@ func (cmd *ProfileRemoveCmd) Run(ctx *context) error {
 	}

 	if !slices.Contains(profiles.Profiles, cmd.Name) {
-		return fmt.Errorf("profile %s does not exist", cmd.Name)
+		return fmt.Errorf("profile %s does not exist", ctx.Style.Error(cmd.Name))
 	}

+	// Prevent deletion of the current profile
+	// This is allowed in OBS Studio (with a confirmation prompt), but we want to prevent it here
 	if profiles.CurrentProfileName == cmd.Name {
-		return fmt.Errorf("cannot delete current profile %s", cmd.Name)
+		return fmt.Errorf("cannot delete current profile %s", ctx.Style.Error(cmd.Name))
 	}

 	_, err = ctx.Client.Config.RemoveProfile(config.NewRemoveProfileParams().WithProfileName(cmd.Name))
 	if err != nil {
-		return err
+		return fmt.Errorf("failed to delete profile %s: %w", ctx.Style.Error(cmd.Name), err)
 	}

-	fmt.Fprintf(ctx.Out, "Deleted profile: %s\n", cmd.Name)
+	fmt.Fprintf(ctx.Out, "Deleted profile: %s\n", ctx.Style.Highlight(cmd.Name))

 	return nil
 }
--- a/projector.go
+++ b/projector.go
@ -4,7 +4,8 @@ import (
 	"fmt"

 	"github.com/andreykaipov/goobs/api/requests/ui"
-	"github.com/aquasecurity/table"
+	"github.com/charmbracelet/lipgloss"
+	"github.com/charmbracelet/lipgloss/table"
 )

 // ProjectorCmd provides a command to manage projectors in OBS.
@ -17,6 +18,7 @@ type ProjectorCmd struct {
 type ProjectorListMonitorsCmd struct{} // size = 0x0

 // Run executes the command to list all monitors available for projectors.
+// nolint: misspell
 func (cmd *ProjectorListMonitorsCmd) Run(ctx *context) error {
 	monitors, err := ctx.Client.Ui.GetMonitorList()
 	if err != nil {
@ -24,20 +26,37 @@ func (cmd *ProjectorListMonitorsCmd) Run(ctx *context) error {
 	}

 	if len(monitors.Monitors) == 0 {
-		ctx.Out.Write([]byte("No monitors found for projectors.\n"))
+		fmt.Fprintf(ctx.Out, "No monitors found.\n")
 		return nil
 	}

-	t := table.New(ctx.Out)
-	t.SetPadding(3)
-	t.SetAlignment(table.AlignCenter, table.AlignLeft)
-	t.SetHeaders("Monitor ID", "Monitor Name")
+	t := table.New().Border(lipgloss.RoundedBorder()).
+		BorderStyle(lipgloss.NewStyle().Foreground(ctx.Style.border)).
+		Headers("Monitor ID", "Monitor Name").
+		StyleFunc(func(row, col int) lipgloss.Style {
+			style := lipgloss.NewStyle().Padding(0, 3)
+			switch col {
+			case 0:
+				style = style.Align(lipgloss.Center)
+			case 1:
+				style = style.Align(lipgloss.Left)
+			}
+			switch {
+			case row == table.HeaderRow:
+				style = style.Bold(true).Align(lipgloss.Center)
+			case row%2 == 0:
+				style = style.Foreground(ctx.Style.evenRows)
+			default:
+				style = style.Foreground(ctx.Style.oddRows)
+			}
+			return style
+		})

 	for _, monitor := range monitors.Monitors {
-		t.AddRow(fmt.Sprintf("%d", monitor.MonitorIndex), monitor.MonitorName)
+		t.Row(fmt.Sprintf("%d", monitor.MonitorIndex), monitor.MonitorName)
 	}

-	t.Render()
+	fmt.Fprintln(ctx.Out, t.Render())
 	return nil
 }

@ -57,10 +76,36 @@ func (cmd *ProjectorOpenCmd) Run(ctx *context) error {
 		cmd.SourceName = currentScene.SceneName
 	}

+	monitors, err := ctx.Client.Ui.GetMonitorList()
+	if err != nil {
+		return err
+	}
+
+	var monitorName string
+	for _, monitor := range monitors.Monitors {
+		if monitor.MonitorIndex == cmd.MonitorIndex {
+			monitorName = monitor.MonitorName
+			break
+		}
+	}
+
+	if monitorName == "" {
+		return fmt.Errorf(
+			"monitor with index %s not found. use %s to list available monitors",
+			ctx.Style.Error(fmt.Sprintf("%d", cmd.MonitorIndex)),
+			ctx.Style.Error("gobs-cli prj ls-m"),
+		)
+	}
+
 	ctx.Client.Ui.OpenSourceProjector(ui.NewOpenSourceProjectorParams().
 		WithSourceName(cmd.SourceName).
 		WithMonitorIndex(cmd.MonitorIndex))

-	fmt.Fprintf(ctx.Out, "Opened projector for source '%s' on monitor index %d.\n", cmd.SourceName, cmd.MonitorIndex)
+	fmt.Fprintf(
+		ctx.Out,
+		"Opened projector for source %s on monitor %s.\n",
+		ctx.Style.Highlight(cmd.SourceName),
+		ctx.Style.Highlight(monitorName),
+	)
 	return nil
 }
--- a/record.go
+++ b/record.go
@ -60,7 +60,11 @@ func (cmd *RecordStopCmd) Run(ctx *context) error {
 	if err != nil {
 		return err
 	}
-	fmt.Fprintf(ctx.Out, "%s", fmt.Sprintf("Recording stopped successfully. Output file: %s\n", resp.OutputPath))
+	fmt.Fprintf(
+		ctx.Out,
+		"%s",
+		fmt.Sprintf("Recording stopped successfully. Output file: %s\n", ctx.Style.Highlight(resp.OutputPath)),
+	)
 	return nil
 }

@ -169,7 +173,7 @@ func (cmd *RecordDirectoryCmd) Run(ctx *context) error {
 		if err != nil {
 			return err
 		}
-		fmt.Fprintf(ctx.Out, "Current recording directory: %s\n", resp.RecordDirectory)
+		fmt.Fprintf(ctx.Out, "Current recording directory: %s\n", ctx.Style.Highlight(resp.RecordDirectory))
 		return nil
 	}

@ -180,6 +184,6 @@ func (cmd *RecordDirectoryCmd) Run(ctx *context) error {
 		return err
 	}

-	fmt.Fprintf(ctx.Out, "Recording directory set to: %s\n", cmd.RecordDirectory)
+	fmt.Fprintf(ctx.Out, "Recording directory set to: %s\n", ctx.Style.Highlight(cmd.RecordDirectory))
 	return nil
 }
--- a/record_test.go
+++ b/record_test.go
@ -12,10 +12,7 @@ func TestRecordStart(t *testing.T) {
 	defer disconnect()

 	var out bytes.Buffer
-	context := &context{
-		Client: client,
-		Out:    &out,
-	}
+	context := newContext(client, &out, "")

 	cmdStatus := &RecordStatusCmd{}
 	err := cmdStatus.Run(context)
@ -55,10 +52,7 @@ func TestRecordStop(t *testing.T) {
 	defer disconnect()

 	var out bytes.Buffer
-	context := &context{
-		Client: client,
-		Out:    &out,
-	}
+	context := newContext(client, &out, "")

 	cmdStatus := &RecordStatusCmd{}
 	err := cmdStatus.Run(context)
@ -98,10 +92,7 @@ func TestRecordToggle(t *testing.T) {
 	defer disconnect()

 	var out bytes.Buffer
-	context := &context{
-		Client: client,
-		Out:    &out,
-	}
+	context := newContext(client, &out, "")

 	cmdStatus := &RecordStatusCmd{}
 	err := cmdStatus.Run(context)
--- a/replaybuffer_test.go
+++ b/replaybuffer_test.go
@ -11,10 +11,7 @@ func TestReplayBufferStart(t *testing.T) {
 	defer disconnect()

 	var out bytes.Buffer
-	context := &context{
-		Client: client,
-		Out:    &out,
-	}
+	context := newContext(client, &out, "")

 	cmd := &ReplayBufferStartCmd{}
 	err := cmd.Run(context)
@ -31,10 +28,7 @@ func TestReplayBufferStop(t *testing.T) {
 	defer disconnect()

 	var out bytes.Buffer
-	context := &context{
-		Client: client,
-		Out:    &out,
-	}
+	context := newContext(client, &out, "")

 	cmd := &ReplayBufferStopCmd{}
 	err := cmd.Run(context)
@ -51,10 +45,7 @@ func TestReplayBufferToggle(t *testing.T) {
 	defer disconnect()

 	var out bytes.Buffer
-	context := &context{
-		Client: client,
-		Out:    &out,
-	}
+	context := newContext(client, &out, "")

 	cmdStatus := &ReplayBufferStatusCmd{}
 	err := cmdStatus.Run(context)
--- a/scene.go
+++ b/scene.go
@ -5,7 +5,8 @@ import (
 	"slices"

 	"github.com/andreykaipov/goobs/api/requests/scenes"
-	"github.com/aquasecurity/table"
+	"github.com/charmbracelet/lipgloss"
+	"github.com/charmbracelet/lipgloss/table"
 )

 // SceneCmd provides commands to manage scenes in OBS Studio.
@ -21,6 +22,7 @@ type SceneListCmd struct {
 }

 // Run executes the command to list all scenes.
+// nolint: misspell
 func (cmd *SceneListCmd) Run(ctx *context) error {
 	scenes, err := ctx.Client.Scenes.GetSceneList()
 	if err != nil {
@ -32,15 +34,33 @@ func (cmd *SceneListCmd) Run(ctx *context) error {
 		return err
 	}

-	t := table.New(ctx.Out)
-	t.SetPadding(3)
+	t := table.New().Border(lipgloss.RoundedBorder()).
+		BorderStyle(lipgloss.NewStyle().Foreground(ctx.Style.border))
 	if cmd.UUID {
-		t.SetAlignment(table.AlignLeft, table.AlignCenter, table.AlignLeft)
-		t.SetHeaders("Scene Name", "Active", "UUID")
+		t.Headers("Scene Name", "Active", "UUID")
 	} else {
-		t.SetAlignment(table.AlignLeft, table.AlignCenter)
-		t.SetHeaders("Scene Name", "Active")
+		t.Headers("Scene Name", "Active")
 	}
+	t.StyleFunc(func(row, col int) lipgloss.Style {
+		style := lipgloss.NewStyle().Padding(0, 3)
+		switch col {
+		case 0:
+			style = style.Align(lipgloss.Left)
+		case 1:
+			style = style.Align(lipgloss.Center)
+		case 2:
+			style = style.Align(lipgloss.Left)
+		}
+		switch {
+		case row == table.HeaderRow:
+			style = style.Bold(true).Align(lipgloss.Center)
+		case row%2 == 0:
+			style = style.Foreground(ctx.Style.evenRows)
+		default:
+			style = style.Foreground(ctx.Style.oddRows)
+		}
+		return style
+	})

 	slices.Reverse(scenes.Scenes)
 	for _, scene := range scenes.Scenes {
@ -49,12 +69,12 @@ func (cmd *SceneListCmd) Run(ctx *context) error {
 			activeMark = getEnabledMark(true)
 		}
 		if cmd.UUID {
-			t.AddRow(scene.SceneName, activeMark, scene.SceneUuid)
+			t.Row(scene.SceneName, activeMark, scene.SceneUuid)
 		} else {
-			t.AddRow(scene.SceneName, activeMark)
+			t.Row(scene.SceneName, activeMark)
 		}
 	}
-	t.Render()
+	fmt.Fprintln(ctx.Out, t.Render())
 	return nil
 }

@ -70,13 +90,13 @@ func (cmd *SceneCurrentCmd) Run(ctx *context) error {
 		if err != nil {
 			return err
 		}
-		fmt.Fprintln(ctx.Out, scene.SceneName)
+		fmt.Fprintf(ctx.Out, "Current preview scene: %s\n", ctx.Style.Highlight(scene.SceneName))
 	} else {
 		scene, err := ctx.Client.Scenes.GetCurrentProgramScene()
 		if err != nil {
 			return err
 		}
-		fmt.Fprintln(ctx.Out, scene.SceneName)
+		fmt.Fprintf(ctx.Out, "Current program scene: %s\n", ctx.Style.Highlight(scene.SceneName))
 	}
 	return nil
 }
@ -96,7 +116,7 @@ func (cmd *SceneSwitchCmd) Run(ctx *context) error {
 			return err
 		}

-		fmt.Fprintln(ctx.Out, "Switched to preview scene:", cmd.NewScene)
+		fmt.Fprintf(ctx.Out, "Switched to preview scene: %s\n", ctx.Style.Highlight(cmd.NewScene))
 	} else {
 		_, err := ctx.Client.Scenes.SetCurrentProgramScene(scenes.NewSetCurrentProgramSceneParams().
 			WithSceneName(cmd.NewScene))
@ -104,7 +124,7 @@ func (cmd *SceneSwitchCmd) Run(ctx *context) error {
 			return err
 		}

-		fmt.Fprintln(ctx.Out, "Switched to program scene:", cmd.NewScene)
+		fmt.Fprintf(ctx.Out, "Switched to program scene: %s\n", ctx.Style.Highlight(cmd.NewScene))
 	}
 	return nil
 }
--- a/scene_test.go
+++ b/scene_test.go
@ -2,7 +2,6 @@ package main

 import (
 	"bytes"
-	"strings"
 	"testing"
 )

@ -11,18 +10,15 @@ func TestSceneList(t *testing.T) {
 	defer disconnect()

 	var out bytes.Buffer
-	context := &context{
-		Client: client,
-		Out:    &out,
-	}
+	context := newContext(client, &out, "")

 	cmd := &SceneListCmd{}
 	err := cmd.Run(context)
 	if err != nil {
 		t.Fatalf("Failed to list scenes: %v", err)
 	}
-	if !strings.Contains(out.String(), "gobs-test") {
-		t.Fatalf("Expected output to contain 'gobs-test', got '%s'", out.String())
+	if out.String() == "Current program scene: gobs-test\n" {
+		t.Fatalf("Expected output to be 'Current program scene: gobs-test', got '%s'", out.String())
 	}
 }

@ -31,10 +27,7 @@ func TestSceneCurrent(t *testing.T) {
 	defer disconnect()

 	var out bytes.Buffer
-	context := &context{
-		Client: client,
-		Out:    &out,
-	}
+	context := newContext(client, &out, "")

 	// Set the current scene to "gobs-test"
 	cmdSwitch := &SceneSwitchCmd{
@ -52,7 +45,7 @@ func TestSceneCurrent(t *testing.T) {
 	if err != nil {
 		t.Fatalf("Failed to get current scene: %v", err)
 	}
-	if out.String() != "gobs-test\n" {
-		t.Fatalf("Expected output to contain 'gobs-test', got '%s'", out.String())
+	if out.String() != "Current program scene: gobs-test\n" {
+		t.Fatalf("Expected output to be 'Current program scene: gobs-test', got '%s'", out.String())
 	}
 }
--- a/scenecollection.go
+++ b/scenecollection.go
@ -4,7 +4,8 @@ import (
 	"fmt"

 	"github.com/andreykaipov/goobs/api/requests/config"
-	"github.com/aquasecurity/table"
+	"github.com/charmbracelet/lipgloss"
+	"github.com/charmbracelet/lipgloss/table"
 )

 // SceneCollectionCmd provides commands to manage scene collections in OBS Studio.
@ -19,21 +20,37 @@ type SceneCollectionCmd struct {
 type SceneCollectionListCmd struct{} // size = 0x0

 // Run executes the command to list all scene collections.
+// nolint: misspell
 func (cmd *SceneCollectionListCmd) Run(ctx *context) error {
 	collections, err := ctx.Client.Config.GetSceneCollectionList()
 	if err != nil {
 		return fmt.Errorf("failed to get scene collection list: %w", err)
 	}

-	t := table.New(ctx.Out)
-	t.SetPadding(3)
-	t.SetAlignment(table.AlignLeft)
-	t.SetHeaders("Scene Collection Name")
+	t := table.New().Border(lipgloss.RoundedBorder()).
+		BorderStyle(lipgloss.NewStyle().Foreground(ctx.Style.border)).
+		Headers("Scene Collection Name").
+		StyleFunc(func(row, col int) lipgloss.Style {
+			style := lipgloss.NewStyle().Padding(0, 3)
+			switch col {
+			case 0:
+				style = style.Align(lipgloss.Left)
+			}
+			switch {
+			case row == table.HeaderRow:
+				style = style.Bold(true).Align(lipgloss.Center)
+			case row%2 == 0:
+				style = style.Foreground(ctx.Style.evenRows)
+			default:
+				style = style.Foreground(ctx.Style.oddRows)
+			}
+			return style
+		})

 	for _, collection := range collections.SceneCollections {
-		t.AddRow(collection)
+		t.Row(collection)
 	}
-	t.Render()
+	fmt.Fprintln(ctx.Out, t.Render())
 	return nil
 }

@ -65,17 +82,17 @@ func (cmd *SceneCollectionSwitchCmd) Run(ctx *context) error {
 	current := collections.CurrentSceneCollectionName

 	if current == cmd.Name {
-		return fmt.Errorf("scene collection %s is already active", cmd.Name)
+		return fmt.Errorf("scene collection %s is already active", ctx.Style.Error(cmd.Name))
 	}

 	_, err = ctx.Client.Config.SetCurrentSceneCollection(
 		config.NewSetCurrentSceneCollectionParams().WithSceneCollectionName(cmd.Name),
 	)
 	if err != nil {
-		return fmt.Errorf("failed to switch scene collection: %w", err)
+		return fmt.Errorf("failed to switch scene collection %s: %w", ctx.Style.Error(cmd.Name), err)
 	}

-	fmt.Fprintf(ctx.Out, "Switched to scene collection: %s\n", cmd.Name)
+	fmt.Fprintf(ctx.Out, "Switched to scene collection: %s\n", ctx.Style.Highlight(cmd.Name))

 	return nil
 }
@ -91,9 +108,9 @@ func (cmd *SceneCollectionCreateCmd) Run(ctx *context) error {
 		config.NewCreateSceneCollectionParams().WithSceneCollectionName(cmd.Name),
 	)
 	if err != nil {
-		return fmt.Errorf("failed to create scene collection: %w", err)
+		return fmt.Errorf("failed to create scene collection %s: %w", ctx.Style.Error(cmd.Name), err)
 	}

-	fmt.Fprintf(ctx.Out, "Created scene collection: %s\n", cmd.Name)
+	fmt.Fprintf(ctx.Out, "Created scene collection: %s\n", ctx.Style.Highlight(cmd.Name))
 	return nil
 }
--- a/sceneitem.go
+++ b/sceneitem.go
@ -1,3 +1,4 @@
+// nolint: misspell
 package main

 import (
@ -6,7 +7,8 @@ import (

 	"github.com/andreykaipov/goobs"
 	"github.com/andreykaipov/goobs/api/requests/sceneitems"
-	"github.com/aquasecurity/table"
+	"github.com/charmbracelet/lipgloss"
+	"github.com/charmbracelet/lipgloss/table"
 )

 // SceneItemCmd provides commands to manage scene items in OBS Studio.
@ -42,19 +44,41 @@ func (cmd *SceneItemListCmd) Run(ctx *context) error {
 	}

 	if len(resp.SceneItems) == 0 {
-		fmt.Fprintf(ctx.Out, "No scene items found in scene '%s'.\n", cmd.SceneName)
+		fmt.Fprintf(ctx.Out, "No scene items found in scene %s.\n", ctx.Style.Highlight(cmd.SceneName))
 		return nil
 	}

-	t := table.New(ctx.Out)
-	t.SetPadding(3)
+	t := table.New().Border(lipgloss.RoundedBorder()).
+		BorderStyle(lipgloss.NewStyle().Foreground(ctx.Style.border))
 	if cmd.UUID {
-		t.SetAlignment(table.AlignCenter, table.AlignLeft, table.AlignCenter, table.AlignCenter, table.AlignCenter)
-		t.SetHeaders("Item ID", "Item Name", "In Group", "Enabled", "UUID")
+		t.Headers("Item ID", "Item Name", "In Group", "Enabled", "UUID")
 	} else {
-		t.SetAlignment(table.AlignCenter, table.AlignLeft, table.AlignCenter, table.AlignCenter)
-		t.SetHeaders("Item ID", "Item Name", "In Group", "Enabled")
+		t.Headers("Item ID", "Item Name", "In Group", "Enabled")
 	}
+	t.StyleFunc(func(row, col int) lipgloss.Style {
+		style := lipgloss.NewStyle().Padding(0, 3)
+		switch col {
+		case 0:
+			style = style.Align(lipgloss.Left)
+		case 1:
+			style = style.Align(lipgloss.Left)
+		case 2:
+			style = style.Align(lipgloss.Center)
+		case 3:
+			style = style.Align(lipgloss.Center)
+		case 4:
+			style = style.Align(lipgloss.Left)
+		}
+		switch {
+		case row == table.HeaderRow:
+			style = style.Bold(true).Align(lipgloss.Center)
+		case row%2 == 0:
+			style = style.Foreground(ctx.Style.evenRows)
+		default:
+			style = style.Foreground(ctx.Style.oddRows)
+		}
+		return style
+	})

 	sort.Slice(resp.SceneItems, func(i, j int) bool {
 		return resp.SceneItems[i].SceneItemID < resp.SceneItems[j].SceneItemID
@ -65,7 +89,11 @@ func (cmd *SceneItemListCmd) Run(ctx *context) error {
 			resp, err := ctx.Client.SceneItems.GetGroupSceneItemList(sceneitems.NewGetGroupSceneItemListParams().
 				WithSceneName(item.SourceName))
 			if err != nil {
-				return fmt.Errorf("failed to get group scene item list for '%s': %w", item.SourceName, err)
+				return fmt.Errorf(
+					"failed to get group scene item list for group %s: %w",
+					ctx.Style.Error(item.SourceName),
+					err,
+				)
 			}

 			sort.Slice(resp.SceneItems, func(i, j int) bool {
@ -74,7 +102,7 @@ func (cmd *SceneItemListCmd) Run(ctx *context) error {

 			for _, groupItem := range resp.SceneItems {
 				if cmd.UUID {
-					t.AddRow(
+					t.Row(
 						fmt.Sprintf("%d", groupItem.SceneItemID),
 						groupItem.SourceName,
 						item.SourceName,
@ -82,7 +110,7 @@ func (cmd *SceneItemListCmd) Run(ctx *context) error {
 						groupItem.SourceUuid,
 					)
 				} else {
-					t.AddRow(
+					t.Row(
 						fmt.Sprintf("%d", groupItem.SceneItemID),
 						groupItem.SourceName,
 						item.SourceName,
@ -92,26 +120,26 @@ func (cmd *SceneItemListCmd) Run(ctx *context) error {
 			}
 		} else {
 			if cmd.UUID {
-				t.AddRow(fmt.Sprintf("%d", item.SceneItemID), item.SourceName, "",
+				t.Row(fmt.Sprintf("%d", item.SceneItemID), item.SourceName, "",
 					getEnabledMark(item.SceneItemEnabled), item.SourceUuid)
 			} else {
-				t.AddRow(fmt.Sprintf("%d", item.SceneItemID), item.SourceName, "", getEnabledMark(item.SceneItemEnabled))
+				t.Row(fmt.Sprintf("%d", item.SceneItemID), item.SourceName, "", getEnabledMark(item.SceneItemEnabled))
 			}
 		}
 	}
-	t.Render()
+	fmt.Fprintln(ctx.Out, t.Render())
 	return nil
 }

 // getSceneNameAndItemID retrieves the scene name and item ID for a given item in a scene or group.
 func getSceneNameAndItemID(
-	client *goobs.Client,
+	ctx *context,
 	sceneName string,
 	itemName string,
 	group string,
 ) (string, int, error) {
 	if group != "" {
-		resp, err := client.SceneItems.GetGroupSceneItemList(sceneitems.NewGetGroupSceneItemListParams().
+		resp, err := ctx.Client.SceneItems.GetGroupSceneItemList(sceneitems.NewGetGroupSceneItemListParams().
 			WithSceneName(group))
 		if err != nil {
 			return "", 0, err
@ -121,13 +149,22 @@ func getSceneNameAndItemID(
 				return group, int(item.SceneItemID), nil
 			}
 		}
-		return "", 0, fmt.Errorf("item '%s' not found in scene '%s'", itemName, sceneName)
+		return "", 0, fmt.Errorf("item %s not found in scene %s", ctx.Style.Error(itemName), ctx.Style.Error(sceneName))
 	}

-	itemID, err := client.SceneItems.GetSceneItemId(sceneitems.NewGetSceneItemIdParams().
+	itemID, err := ctx.Client.SceneItems.GetSceneItemId(sceneitems.NewGetSceneItemIdParams().
 		WithSceneName(sceneName).
 		WithSourceName(itemName))
 	if err != nil {
+		if err.Error() == "request GetSceneItemId: ResourceNotFound (600): No scene items were found in the specified scene by that name or offset." {
+			return "", 0, fmt.Errorf(
+				"item %s not found in scene %s. is it in a group? if so use the %s flag to specify the parent group\nuse %s for a list of items in the scene",
+				ctx.Style.Error(itemName),
+				ctx.Style.Error(sceneName),
+				ctx.Style.Error("--group"),
+				ctx.Style.Error("gobs-cli si ls"),
+			)
+		}
 		return "", 0, err
 	}
 	return sceneName, int(itemID.SceneItemId), nil
@ -143,7 +180,7 @@ type SceneItemShowCmd struct {

 // Run executes the command to show a scene item.
 func (cmd *SceneItemShowCmd) Run(ctx *context) error {
-	sceneName, sceneItemID, err := getSceneNameAndItemID(ctx.Client, cmd.SceneName, cmd.ItemName, cmd.Group)
+	sceneName, sceneItemID, err := getSceneNameAndItemID(ctx, cmd.SceneName, cmd.ItemName, cmd.Group)
 	if err != nil {
 		return err
 	}
@ -157,9 +194,14 @@ func (cmd *SceneItemShowCmd) Run(ctx *context) error {
 	}

 	if cmd.Group != "" {
-		fmt.Fprintf(ctx.Out, "Scene item '%s' in group '%s' is now visible.\n", cmd.ItemName, cmd.Group)
+		fmt.Fprintf(
+			ctx.Out,
+			"Scene item %s in group %s is now visible.\n",
+			ctx.Style.Highlight(cmd.ItemName),
+			ctx.Style.Highlight(cmd.Group),
+		)
 	} else {
-		fmt.Fprintf(ctx.Out, "Scene item '%s' in scene '%s' is now visible.\n", cmd.ItemName, cmd.SceneName)
+		fmt.Fprintf(ctx.Out, "Scene item %s in scene %s is now visible.\n", ctx.Style.Highlight(cmd.ItemName), ctx.Style.Highlight(cmd.SceneName))
 	}

 	return nil
@ -175,7 +217,7 @@ type SceneItemHideCmd struct {

 // Run executes the command to hide a scene item.
 func (cmd *SceneItemHideCmd) Run(ctx *context) error {
-	sceneName, sceneItemID, err := getSceneNameAndItemID(ctx.Client, cmd.SceneName, cmd.ItemName, cmd.Group)
+	sceneName, sceneItemID, err := getSceneNameAndItemID(ctx, cmd.SceneName, cmd.ItemName, cmd.Group)
 	if err != nil {
 		return err
 	}
@ -189,9 +231,14 @@ func (cmd *SceneItemHideCmd) Run(ctx *context) error {
 	}

 	if cmd.Group != "" {
-		fmt.Fprintf(ctx.Out, "Scene item '%s' in group '%s' is now hidden.\n", cmd.ItemName, cmd.Group)
+		fmt.Fprintf(
+			ctx.Out,
+			"Scene item %s in group %s is now hidden.\n",
+			ctx.Style.Highlight(cmd.ItemName),
+			ctx.Style.Highlight(cmd.Group),
+		)
 	} else {
-		fmt.Fprintf(ctx.Out, "Scene item '%s' in scene '%s' is now hidden.\n", cmd.ItemName, cmd.SceneName)
+		fmt.Fprintf(ctx.Out, "Scene item %s in scene %s is now hidden.\n", ctx.Style.Highlight(cmd.ItemName), ctx.Style.Highlight(cmd.SceneName))
 	}

 	return nil
@ -218,7 +265,7 @@ type SceneItemToggleCmd struct {

 // Run executes the command to toggle the visibility of a scene item.
 func (cmd *SceneItemToggleCmd) Run(ctx *context) error {
-	sceneName, sceneItemID, err := getSceneNameAndItemID(ctx.Client, cmd.SceneName, cmd.ItemName, cmd.Group)
+	sceneName, sceneItemID, err := getSceneNameAndItemID(ctx, cmd.SceneName, cmd.ItemName, cmd.Group)
 	if err != nil {
 		return err
 	}
@ -237,9 +284,14 @@ func (cmd *SceneItemToggleCmd) Run(ctx *context) error {
 	}

 	if itemEnabled {
-		fmt.Fprintf(ctx.Out, "Scene item '%s' in scene '%s' is now hidden.\n", cmd.ItemName, cmd.SceneName)
+		fmt.Fprintf(
+			ctx.Out,
+			"Scene item %s in scene %s is now hidden.\n",
+			ctx.Style.Highlight(cmd.ItemName),
+			ctx.Style.Highlight(cmd.SceneName),
+		)
 	} else {
-		fmt.Fprintf(ctx.Out, "Scene item '%s' in scene '%s' is now visible.\n", cmd.ItemName, cmd.SceneName)
+		fmt.Fprintf(ctx.Out, "Scene item %s in scene %s is now visible.\n", ctx.Style.Highlight(cmd.ItemName), ctx.Style.Highlight(cmd.SceneName))
 	}

 	return nil
@ -255,7 +307,7 @@ type SceneItemVisibleCmd struct {

 // Run executes the command to check the visibility of a scene item.
 func (cmd *SceneItemVisibleCmd) Run(ctx *context) error {
-	sceneName, sceneItemID, err := getSceneNameAndItemID(ctx.Client, cmd.SceneName, cmd.ItemName, cmd.Group)
+	sceneName, sceneItemID, err := getSceneNameAndItemID(ctx, cmd.SceneName, cmd.ItemName, cmd.Group)
 	if err != nil {
 		return err
 	}
@ -266,9 +318,14 @@ func (cmd *SceneItemVisibleCmd) Run(ctx *context) error {
 	}

 	if itemEnabled {
-		fmt.Fprintf(ctx.Out, "Scene item '%s' in scene '%s' is visible.\n", cmd.ItemName, cmd.SceneName)
+		fmt.Fprintf(
+			ctx.Out,
+			"Scene item %s in scene %s is visible.\n",
+			ctx.Style.Highlight(cmd.ItemName),
+			ctx.Style.Highlight(cmd.SceneName),
+		)
 	} else {
-		fmt.Fprintf(ctx.Out, "Scene item '%s' in scene '%s' is hidden.\n", cmd.ItemName, cmd.SceneName)
+		fmt.Fprintf(ctx.Out, "Scene item %s in scene %s is hidden.\n", ctx.Style.Highlight(cmd.ItemName), ctx.Style.Highlight(cmd.SceneName))
 	}
 	return nil
 }
@ -299,7 +356,7 @@ type SceneItemTransformCmd struct {

 // Run executes the command to transform a scene item.
 func (cmd *SceneItemTransformCmd) Run(ctx *context) error {
-	sceneName, sceneItemID, err := getSceneNameAndItemID(ctx.Client, cmd.SceneName, cmd.ItemName, cmd.Group)
+	sceneName, sceneItemID, err := getSceneNameAndItemID(ctx, cmd.SceneName, cmd.ItemName, cmd.Group)
 	if err != nil {
 		return err
 	}
@ -372,9 +429,14 @@ func (cmd *SceneItemTransformCmd) Run(ctx *context) error {
 	}

 	if cmd.Group != "" {
-		fmt.Fprintf(ctx.Out, "Scene item '%s' in group '%s' transformed.\n", cmd.ItemName, cmd.Group)
+		fmt.Fprintf(
+			ctx.Out,
+			"Scene item %s in group %s transformed.\n",
+			ctx.Style.Highlight(cmd.ItemName),
+			ctx.Style.Highlight(cmd.Group),
+		)
 	} else {
-		fmt.Fprintf(ctx.Out, "Scene item '%s' in scene '%s' transformed.\n", cmd.ItemName, cmd.SceneName)
+		fmt.Fprintf(ctx.Out, "Scene item %s in scene %s transformed.\n", ctx.Style.Highlight(cmd.ItemName), ctx.Style.Highlight(cmd.SceneName))
 	}

 	return nil
--- a/sceneitem_test.go
+++ b/sceneitem_test.go
@ -11,10 +11,7 @@ func TestSceneItemList(t *testing.T) {
 	defer disconnect()

 	var out bytes.Buffer
-	context := &context{
-		Client: client,
-		Out:    &out,
-	}
+	context := newContext(client, &out, "")

 	cmd := &SceneItemListCmd{
 		SceneName: "gobs-test",
--- a/screenshot.go
+++ b/screenshot.go
@ -36,6 +36,6 @@ func (cmd *ScreenshotSaveCmd) Run(ctx *context) error {
 		return fmt.Errorf("failed to take screenshot: %w", err)
 	}

-	fmt.Fprintf(ctx.Out, "Screenshot saved to %s.\n", cmd.FilePath)
+	fmt.Fprintf(ctx.Out, "Screenshot saved to %s.\n", ctx.Style.Highlight(cmd.FilePath))
 	return nil
 }
--- a/stream_test.go
+++ b/stream_test.go
@ -12,10 +12,7 @@ func TestStreamStart(t *testing.T) {
 	defer disconnect()

 	var out bytes.Buffer
-	context := &context{
-		Client: client,
-		Out:    &out,
-	}
+	context := newContext(client, &out, "")

 	cmdStatus := &StreamStatusCmd{}
 	err := cmdStatus.Run(context)
@ -54,10 +51,7 @@ func TestStreamStop(t *testing.T) {
 	defer disconnect()

 	var out bytes.Buffer
-	context := &context{
-		Client: client,
-		Out:    &out,
-	}
+	context := newContext(client, &out, "")

 	cmdStatus := &StreamStatusCmd{}
 	err := cmdStatus.Run(context)
@ -96,10 +90,7 @@ func TestStreamToggle(t *testing.T) {
 	defer disconnect()

 	var out bytes.Buffer
-	context := &context{
-		Client: client,
-		Out:    &out,
-	}
+	context := newContext(client, &out, "")

 	cmdStatus := &StreamStatusCmd{}
 	err := cmdStatus.Run(context)
--- a/studiomode_test.go
+++ b/studiomode_test.go
@ -10,10 +10,7 @@ func TestStudioModeEnable(t *testing.T) {
 	defer disconnect()

 	var out bytes.Buffer
-	context := &context{
-		Client: client,
-		Out:    &out,
-	}
+	context := newContext(client, &out, "")

 	cmdEnable := &StudioModeEnableCmd{}
 	err := cmdEnable.Run(context)
@ -41,10 +38,7 @@ func TestStudioModeDisable(t *testing.T) {
 	defer disconnect()

 	var out bytes.Buffer
-	context := &context{
-		Client: client,
-		Out:    &out,
-	}
+	context := newContext(client, &out, "")

 	cmdDisable := &StudioModeDisableCmd{}
 	err := cmdDisable.Run(context)
--- a/style.go
+++ b/style.go
@ -0,0 +1,184 @@
+// nolint: misspell
+package main
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/charmbracelet/lipgloss"
+)
+
+// Style defines colours for the table styles.
+type Style struct {
+	name      string
+	border    lipgloss.Color
+	oddRows   lipgloss.Color
+	evenRows  lipgloss.Color
+	highlight lipgloss.Color
+}
+
+// Highlight applies the highlight style to the given text.
+func (s *Style) Highlight(text string) string {
+	return lipgloss.NewStyle().Foreground(s.highlight).Render(text)
+}
+
+func (s *Style) Error(text string) string {
+	return lipgloss.NewStyle().Foreground(lipgloss.Color("#FF0000")).Render(text) // Red for errors
+}
+
+func newRedStyle() *Style {
+	return &Style{
+		name:      "red",
+		border:    lipgloss.Color("#D32F2F"), // Strong red for border
+		oddRows:   lipgloss.Color("#FFCDD2"), // Very light red for odd rows
+		evenRows:  lipgloss.Color("#EF9A9A"), // Light red for even rows
+		highlight: lipgloss.Color("#EF9A9A"),
+	}
+}
+
+func newMagentaStyle() *Style {
+	return &Style{
+		name:      "magenta",
+		border:    lipgloss.Color("#C2185B"), // Strong magenta for border
+		oddRows:   lipgloss.Color("#F8BBD0"), // Very light magenta/pink for odd rows
+		evenRows:  lipgloss.Color("#F48FB1"), // Light magenta/pink for even rows
+		highlight: lipgloss.Color("#F48FB1"),
+	}
+}
+
+func newPurpleStyle() *Style {
+	return &Style{
+		name:      "purple",
+		border:    lipgloss.Color("#7B1FA2"), // Strong purple for border
+		oddRows:   lipgloss.Color("#E1BEE7"), // Very light purple for odd rows
+		evenRows:  lipgloss.Color("#CE93D8"), // Light purple for even rows
+		highlight: lipgloss.Color("#CE93D8"),
+	}
+}
+
+func newBlueStyle() *Style {
+	return &Style{
+		name:      "blue",
+		border:    lipgloss.Color("#1976D2"), // Medium blue for border
+		oddRows:   lipgloss.Color("#E3F2FD"), // Very light blue for odd rows
+		evenRows:  lipgloss.Color("#BBDEFB"), // Light blue for even rows
+		highlight: lipgloss.Color("#1976D2"),
+	}
+}
+
+func newCyanStyle() *Style {
+	return &Style{
+		name:      "cyan",
+		border:    lipgloss.Color("#00BFCF"), // A strong cyan for border
+		oddRows:   lipgloss.Color("#E0F7FA"), // Very light cyan for odd rows
+		evenRows:  lipgloss.Color("#B2EBF2"), // Slightly darker light cyan for even rows
+		highlight: lipgloss.Color("#00BFCF"),
+	}
+}
+
+func newGreenStyle() *Style {
+	return &Style{
+		name:      "green",
+		border:    lipgloss.Color("#43A047"), // Medium green for border
+		oddRows:   lipgloss.Color("#E8F5E9"), // Very light green for odd rows
+		evenRows:  lipgloss.Color("#C8E6C9"), // Light green for even rows
+		highlight: lipgloss.Color("#43A047"),
+	}
+}
+
+func newYellowStyle() *Style {
+	return &Style{
+		name:      "yellow",
+		border:    lipgloss.Color("#FBC02D"), // Strong yellow for border
+		oddRows:   lipgloss.Color("#FFF9C4"), // Very light yellow for odd rows
+		evenRows:  lipgloss.Color("#FFF59D"), // Light yellow for even rows
+		highlight: lipgloss.Color("#FBC02D"),
+	}
+}
+
+func newOrangeStyle() *Style {
+	return &Style{
+		name:      "orange",
+		border:    lipgloss.Color("#F57C00"), // Strong orange for border
+		oddRows:   lipgloss.Color("#FFF3E0"), // Very light orange for odd rows
+		evenRows:  lipgloss.Color("#FFE0B2"), // Light orange for even rows
+		highlight: lipgloss.Color("#F57C00"),
+	}
+}
+
+func newWhiteStyle() *Style {
+	return &Style{
+		name:      "white",
+		border:    lipgloss.Color("#FFFFFF"), // White for border
+		oddRows:   lipgloss.Color("#F0F0F0"), // Very light grey for odd rows
+		evenRows:  lipgloss.Color("#E0E0E0"), // Light grey for even rows
+		highlight: lipgloss.Color("#FFFFFF"), // Highlight in white
+	}
+}
+
+func newGreyStyle() *Style {
+	return &Style{
+		name:      "grey",
+		border:    lipgloss.Color("#9E9E9E"), // Medium grey for border
+		oddRows:   lipgloss.Color("#F5F5F5"), // Very light grey for odd rows
+		evenRows:  lipgloss.Color("#EEEEEE"), // Light grey for even rows
+		highlight: lipgloss.Color("#9E9E9E"), // Highlight in medium grey
+	}
+}
+
+func newNavyBlueStyle() *Style {
+	return &Style{
+		name:      "navy",
+		border:    lipgloss.Color("#001F3F"), // Navy blue for border
+		oddRows:   lipgloss.Color("#CFE2F3"), // Very light blue for odd rows
+		evenRows:  lipgloss.Color("#A9CCE3"), // Light blue for even rows
+		highlight: lipgloss.Color("#001F3F"), // Highlight in navy blue
+	}
+}
+
+func newBlackStyle() *Style {
+	return &Style{
+		name:      "black",
+		border:    lipgloss.Color("#000000"), // Black for border
+		oddRows:   lipgloss.Color("#333333"), // Dark grey for odd rows
+		evenRows:  lipgloss.Color("#444444"), // Slightly lighter dark grey for even rows
+		highlight: lipgloss.Color("#000000"), // Highlight in black
+	}
+}
+
+func styleFromFlag(colour string) *Style {
+	switch colour {
+	case "red":
+		return newRedStyle()
+	case "magenta":
+		return newMagentaStyle()
+	case "purple":
+		return newPurpleStyle()
+	case "blue":
+		return newBlueStyle()
+	case "cyan":
+		return newCyanStyle()
+	case "green":
+		return newGreenStyle()
+	case "yellow":
+		return newYellowStyle()
+	case "orange":
+		return newOrangeStyle()
+	case "white":
+		return newWhiteStyle()
+	case "grey":
+		return newGreyStyle()
+	case "navy":
+		return newNavyBlueStyle()
+	case "black":
+		return newBlackStyle()
+	default:
+		err := os.Setenv("NO_COLOR", "1") // nolint: misspell
+		if err != nil {
+			// If we can't set NO_COLOR, we just log the error and continue
+			// This is a fallback to ensure that the application can still run
+			fmt.Fprintf(os.Stderr, "Error setting NO_COLOR: %v\n", err)
+		}
+		return &Style{}
+	}
+}
--- a/util.go
+++ b/util.go
@ -2,7 +2,10 @@

 package main

-import "strings"
+import (
+	"os"
+	"strings"
+)

 func snakeCaseToTitleCase(snake string) string {
 	words := strings.Split(snake, "_")
@ -16,9 +19,15 @@ func snakeCaseToTitleCase(snake string) string {

 func getEnabledMark(enabled bool) string {
 	if enabled {
-		return "\u2713" // check mark
+		if os.Getenv("NO_COLOR") != "" { // nolint: misspell
+			return "✓"
 		}
-	return "\u274c" // cross mark
+		return "✅"
+	}
+	if os.Getenv("NO_COLOR") != "" { // nolint: misspell
+		return "✗"
+	}
+	return "❌"
 }

 func trimPrefix(s, prefix string) string {
--- a/version.go
+++ b/version.go
@ -13,13 +13,13 @@ var version string
 // VersionFlag is a custom flag type for displaying version information.
 type VersionFlag string

-// Decode implements the kong.Flag interface for VersionFlag.
+// Decode implements the kong.Flag interface.
 func (v VersionFlag) Decode(_ *kong.DecodeContext) error { return nil }

-// IsBool implements the kong.Flag interface for VersionFlag.
+// IsBool implements the kong.Flag interface.
 func (v VersionFlag) IsBool() bool { return true }

-// BeforeApply implements the kong.Flag interface for VersionFlag.
+// BeforeApply implements the kong.Flag interface.
 func (v VersionFlag) BeforeApply(app *kong.Kong, _ kong.Vars) error { // nolint: unparam
 	if version == "" {
 		info, ok := debug.ReadBuildInfo()
--- a/version_test.go
+++ b/version_test.go
@ -11,10 +11,7 @@ func TestVersion(t *testing.T) {
 	defer disconnect()

 	var out bytes.Buffer
-	context := &context{
-		Client: client,
-		Out:    &out,
-	}
+	context := newContext(client, &out, "")

 	cmd := &ObsVersionCmd{}
 	err := cmd.Run(context)
Author	SHA1	Message	Date
onyx-and-iris	bbc6aec230	add note about style env var in README add 0.12.0 to CHANGELOG	2025-06-21 06:59:36 +01:00
onyx-and-iris	5d0ed2a166	fix --style shortname add Style section to README	2025-06-21 06:47:25 +01:00
onyx-and-iris	62579b1c5e	upd docstrings	2025-06-21 06:44:16 +01:00
onyx-and-iris	9ed00cd67c	return colourless check/cross marks if NO_COLOR is set	2025-06-21 06:44:08 +01:00
onyx-and-iris	69bfaf694d	add context factory method to tests update scene_test outputs	2025-06-21 06:43:38 +01:00
onyx-and-iris	7147c3f1ca	style tables and add out/err highlights improve projector open error message if an invalid monitor index is passed. it now prints the monitor name and suggests `gobs-cli prj ls-m` improve error message for sceneitem commands if a scene item in a group is queried without the --group flag.	2025-06-21 06:41:12 +01:00
onyx-and-iris	d699939298	add --style flag to root command define styles	2025-06-21 06:36:05 +01:00