onyx_online/gobs-cli
1
0
Fork 0
mirror of https://github.com/onyx-and-iris/gobs-cli.git synced 2025-06-13 15:10:33 +01:00
Code Issues Packages Projects Releases Wiki Activity

Compare commits

base: onyx_online:main
Branches Tags
onyx_online:main
onyx_online:v0.10.3
onyx_online:v0.10.2
onyx_online:v0.10.1
onyx_online:v0.10.0
onyx_online:v0.9.2
onyx_online:v0.9.1
onyx_online:v0.9.0
onyx_online:v0.8.2
onyx_online:v0.8.1
onyx_online:v0.8.0
onyx_online:v0.7.0
onyx_online:v0.6.2
onyx_online:v0.6.1
onyx_online:v0.6.0
onyx_online:v0.5.0
onyx_online:v0.4.2
onyx_online:v0.4.1
onyx_online:v0.4.0
onyx_online:v0.3.1
onyx_online:v0.3.0
onyx_online:v0.2.0
onyx_online:v0.1.1
onyx_online:v0.1.0
..
compare: onyx_online:v0.6.2
Branches Tags
onyx_online:main
onyx_online:v0.10.3
onyx_online:v0.10.2
onyx_online:v0.10.1
onyx_online:v0.10.0
onyx_online:v0.9.2
onyx_online:v0.9.1
onyx_online:v0.9.0
onyx_online:v0.8.2
onyx_online:v0.8.1
onyx_online:v0.8.0
onyx_online:v0.7.0
onyx_online:v0.6.2
onyx_online:v0.6.1
onyx_online:v0.6.0
onyx_online:v0.5.0
onyx_online:v0.4.2
onyx_online:v0.4.1
onyx_online:v0.4.0
onyx_online:v0.3.1
onyx_online:v0.3.0
onyx_online:v0.2.0
onyx_online:v0.1.1
onyx_online:v0.1.0

No commits in common. "main" and "v0.6.2" have entirely different histories.
main ... v0.6.2

21 changed files with 151 additions and 960 deletions
Show Stats Expand all files Collapse all files

64
CHANGELOG.md
View File

@ -5,72 +5,12 @@ 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.10.3] - 2025-06-07
### Added
- filter list:
- --ffmpeg, --vlc flags
- Muted column to list table
# [0.10.2] - 2025-06-04
### Added
- screenshot save command, see [ScreenshotCmd](https://github.com/onyx-and-iris/gobs-cli?tab=readme-ov-file#screenshotcmd)
### Fixed
- filter list:
- sourceName arg now defaults to current scene.
- defaults are printed for any unmodified values.
- sceneitem list:
- prints enabled mark instead of true/false
# [0.9.0] - 2025-06-02
### Added
- --version/-v option. See [Flags](https://github.com/onyx-and-iris/gobs-cli?tab=readme-ov-file#flags)
### Changed
- version command renamed to obs-version
# [0.8.2] - 2025-05-29
### Added
- record start/stop and stream start/stop commands check outputActive states first.
- Errors are returned if the command cannot be performed.
### Changed
- The --parent flag for the sceneitem commands has been renamed to --group, see [SceneItemCmd](https://github.com/onyx-and-iris/gobs-cli?tab=readme-ov-file#sceneitemcmd)
# [0.8.0] - 2025-05-27
### Added
- record directory command, see [directory under RecordCmd](https://github.com/onyx-and-iris/gobs-cli?tab=readme-ov-file#recordcmd)
### Changed
- record stop now prints the output path of the recording.
# [0.7.0] - 2025-05-26
### Added
- projector commands, see [ProjectorCmd](https://github.com/onyx-and-iris/gobs-cli?tab=readme-ov-file#projectorcmd)
# [0.6.1] - 2025-05-25
### Added
- filter commands, see [FilterCmd](https://github.com/onyx-and-iris/gobs-cli?tab=readme-ov-file#filtercmd)
- filter commands, see [Filter](https://github.com/onyx-and-iris/gobs-cli?tab=readme-ov-file#filtercmd)
### Changed
@ -81,7 +21,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
### Added
- hotkey commands, see [HotkeyCmd](https://github.com/onyx-and-iris/gobs-cli?tab=readme-ov-file#hotkeycmd)
- hotkey commands, see [Hotkey](https://github.com/onyx-and-iris/gobs-cli?tab=readme-ov-file#hotkeycmd)
# [0.4.2] - 2025-05-08

95
README.md
View File

@ -14,16 +14,10 @@ go install github.com/onyx-and-iris/gobs-cli@latest
#### Flags
- --host/-H: Websocket host
- --port/-P Websocket port
- --password/-p: Websocket password
- --timeout/-T: Websocket timeout
- --version/-v: Print the gobs-cli version
Pass `--host`, `--port` and `--password` as flags on the root command, for example:
Pass `--host`, `--port` and `--password` as flags to the root command, for example:
```console
gobs-cli --host localhost --port 4455 --password 'websocket password' --help
gobs-cli --host=localhost --port=4455 --password=<websocket password> --help
```
#### Environment Variables
@ -43,12 +37,10 @@ OBS_TIMEOUT=5
## Commands
### ObsVersionCmd
- Print OBS client and websocket version.
### VersionCmd
```console
gobs-cli obs-version
gobs-cli version
```
### SceneCmd
@ -102,7 +94,7 @@ gobs-cli sceneitem list LIVE
- flags:
*optional*
- --group: Parent group name.
- --parent: Parent group name.
- args: SceneName ItemName
```console
@ -113,7 +105,7 @@ gobs-cli sceneitem show START "Colour Source"
- flags:
*optional*
- --group: Parent group name.
- --parent: Parent group name.
- args: SceneName ItemName
```console
@ -124,29 +116,29 @@ gobs-cli sceneitem hide START "Colour Source"
- flags:
*optional*
- --group: Parent group name.
- --parent: Parent group name.
- args: SceneName ItemName
```console
gobs-cli sceneitem toggle --group=test_group START "Colour Source 3"
gobs-cli sceneitem toggle --parent=test_group START "Colour Source 3"
```
- visible: Get scene item visibility.
- flags:
*optional*
- --group: Parent group name.
- --parent: Parent group name.
- args: SceneName ItemName
```console
gobs-cli sceneitem visible --group=test_group START "Colour Source 4"
gobs-cli sceneitem visible --parent=test_group START "Colour Source 4"
```
- transform: Transform scene item.
- flags:
*optional*
- --group: Parent group name.
- --parent: Parent group name.
- --alignment: Alignment of the scene item.
- --bounds-alignment: Bounds alignment of the scene item.
@ -223,8 +215,6 @@ gobs-cli group status START "test_group"
- --input: List all inputs.
- --output: List all outputs.
- --colour: List all colour sources.
- --ffmpeg: List all ffmpeg sources.
- --vlc: List all VLC sources.
```console
gobs-cli input list
@ -291,19 +281,6 @@ gobs-cli record pause
gobs-cli record resume
```
- directory: Get/Set recording directory.
*optional*
- args: RecordDirectory
- if not passed the current record directory will be printed.
```console
gobs-cli record directory
gobs-cli record directory "/home/me/obs-vids/"
gobs-cli record directory "C:/Users/me/Videos"
```
### StreamCmd
- start: Start streaming.
@ -515,10 +492,6 @@ gobs-cli hotkey trigger-sequence OBS_KEY_F1 --shift --ctrl
- list: List all filters.
*optional*
- args: SourceName
- defaults to current scene
```console
gobs-cli filter list
```
@ -551,52 +524,6 @@ gobs-cli toggle 'Mic/Aux' 'Gain'
gobs-cli status 'Mic/Aux' 'Gain'
```
### ProjectorCmd
- list-monitors: List available monitors.
```console
gobs-cli projector list-monitors
```
- open: Open a fullscreen projector for a source on a specific monitor.
- flags:
*optional*
- --monitor-index: Index of the monitor to open the projector on.
- defaults to 0
*optional*
- args: SourceName
- defaults to current scene
```console
gobs-cli projector open
gobs-cli projector open --monitor-index=1 "test_scene"
gobs-cli projector open --monitor-index=1 "test_group"
```
### ScreenshotCmd
- save: Take a screenshot and save it to a file.
- flags:
*optional*
- --width:
- defaults to 1920
- --height:
- defaults to 1080
- --quality:
- defaults to -1
- args: SourceName FilePath
```console
gobs-cli screenshot save --width=2560 --height=1440 "Scene" "C:\Users\me\Videos\screenshot.png"
```
[userconfigdir]: https://pkg.go.dev/os#UserConfigDir
[obs-keyids]: https://github.com/obsproject/obs-studio/blob/master/libobs/obs-hotkeys.h

6
Taskfile.yaml
View File

@ -7,8 +7,6 @@ vars:
PROGRAM: gobs-cli
SHELL: '{{if eq .OS "Windows_NT"}}powershell{{end}}'
BIN_DIR: bin
VERSION:
sh: 'git describe --tags $(git rev-list --tags --max-count=1)'
tasks:
default:
@ -37,13 +35,13 @@ tasks:
build-windows:
desc: Build the gobs-cli project for Windows
cmds:
- GOOS=windows GOARCH=amd64 go build -ldflags "-X 'main.version={{.VERSION}}'" -o {{.BIN_DIR}}/{{.PROGRAM}}_windows_amd64.exe
- GOOS=windows GOARCH=amd64 go build -o {{.BIN_DIR}}/{{.PROGRAM}}_windows_amd64.exe
internal: true
build-linux:
desc: Build the gobs-cli project for Linux
cmds:
- GOOS=linux GOARCH=amd64 go build -ldflags "-X 'main.version={{.VERSION}}'" -o {{.BIN_DIR}}/{{.PROGRAM}}_linux_amd64
- GOOS=linux GOARCH=amd64 go build -o {{.BIN_DIR}}/{{.PROGRAM}}_linux_amd64
internal: true
test:

31
filter.go
View File

@ -2,7 +2,6 @@ package main
import (
"fmt"
"maps"
"sort"
"strings"
@ -21,27 +20,19 @@ type FilterCmd struct {
// FilterListCmd provides a command to list all filters in a scene.
type FilterListCmd struct {
SourceName string `arg:"" help:"Name of the source to list filters from." default:""`
SourceName string `arg:"" help:"Name of the source to list filters from."`
}
// Run executes the command to list all filters in a scene.
func (cmd *FilterListCmd) Run(ctx *context) error {
if cmd.SourceName == "" {
currentScene, err := ctx.Client.Scenes.GetCurrentProgramScene()
if err != nil {
return fmt.Errorf("failed to get current program scene: %w", err)
}
cmd.SourceName = currentScene.SceneName
}
sourceFilters, err := ctx.Client.Filters.GetSourceFilterList(
filters, err := ctx.Client.Filters.GetSourceFilterList(
filters.NewGetSourceFilterListParams().WithSourceName(cmd.SourceName),
)
if err != nil {
return err
}
if len(sourceFilters.Filters) == 0 {
if len(filters.Filters) == 0 {
fmt.Fprintf(ctx.Out, "No filters found for source %s.\n", cmd.SourceName)
return nil
}
@ -51,20 +42,10 @@ func (cmd *FilterListCmd) Run(ctx *context) error {
t.SetAlignment(table.AlignLeft, table.AlignLeft, table.AlignCenter, table.AlignLeft)
t.SetHeaders("Filter Name", "Kind", "Enabled", "Settings")
for _, filter := range sourceFilters.Filters {
defaultSettings, err := ctx.Client.Filters.GetSourceFilterDefaultSettings(
filters.NewGetSourceFilterDefaultSettingsParams().
WithFilterKind(filter.FilterKind),
)
if err != nil {
return fmt.Errorf("failed to get default settings for filter %s: %w",
filter.FilterName, err)
}
maps.Insert(defaultSettings.DefaultFilterSettings, maps.All(filter.FilterSettings))
for _, filter := range filters.Filters {
var lines []string
for k, v := range defaultSettings.DefaultFilterSettings {
lines = append(lines, fmt.Sprintf("%s: %v", snakeCaseToTitleCase(k), v))
for k, v := range filter.FilterSettings {
lines = append(lines, fmt.Sprintf("%s %v", k, v))
}
sort.Slice(lines, func(i, j int) bool {
return strings.ToLower(lines[i]) < strings.ToLower(lines[j])

76
filter_test.go
View File

@ -1,76 +0,0 @@
package main
import (
"bytes"
"strings"
"testing"
)
func TestFilterList(t *testing.T) {
client, disconnect := getClient(t)
defer disconnect()
var out bytes.Buffer
context := &context{
Client: client,
Out: &out,
}
cmd := &FilterListCmd{
SourceName: "Mic/Aux",
}
err := cmd.Run(context)
if err != nil {
t.Fatalf("Failed to list filters: %v", err)
}
if !strings.Contains(out.String(), "test_filter") {
t.Fatalf("Expected output to contain 'test_filter', got '%s'", out.String())
}
}
func TestFilterListScene(t *testing.T) {
client, disconnect := getClient(t)
defer disconnect()
var out bytes.Buffer
context := &context{
Client: client,
Out: &out,
}
cmd := &FilterListCmd{
SourceName: "gobs-test",
}
err := cmd.Run(context)
if err != nil {
t.Fatalf("Failed to list filters in scene: %v", err)
}
if !strings.Contains(out.String(), "test_filter") {
t.Fatalf("Expected output to contain 'test_filter', got '%s'", out.String())
}
}
func TestFilterListEmpty(t *testing.T) {
client, disconnect := getClient(t)
defer disconnect()
var out bytes.Buffer
context := &context{
Client: client,
Out: &out,
}
cmd := &FilterListCmd{
SourceName: "NonExistentSource",
}
err := cmd.Run(context)
if err == nil {
t.Fatal("Expected error for non-existent source, but got none")
}
if !strings.Contains(err.Error(), "No source was found by the name of `NonExistentSource`.") {
t.Fatalf(
"Expected error to contain 'No source was found by the name of `NonExistentSource`.', got '%s'",
err.Error(),
)
}
}

51
input.go
View File

@ -21,8 +21,6 @@ type InputListCmd struct {
Input bool `flag:"" help:"List all inputs." aliases:"i"`
Output bool `flag:"" help:"List all outputs." aliases:"o"`
Colour bool `flag:"" help:"List all colour sources." aliases:"c"`
Ffmpeg bool `flag:"" help:"List all ffmpeg sources." aliases:"f"`
Vlc bool `flag:"" help:"List all VLC sources." aliases:"v"`
}
// Run executes the command to list all inputs.
@ -34,47 +32,22 @@ func (cmd *InputListCmd) Run(ctx *context) error {
t := table.New(ctx.Out)
t.SetPadding(3)
t.SetAlignment(table.AlignLeft, table.AlignLeft, table.AlignCenter)
t.SetHeaders("Input Name", "Kind", "Muted")
t.SetAlignment(table.AlignLeft, table.AlignLeft)
t.SetHeaders("Input Name", "Kind")
for _, input := range resp.Inputs {
var muteMark string
for _, kind := range []string{"input", "output", "ffmpeg", "vlc"} {
if strings.Contains(input.InputKind, kind) {
resp, err := ctx.Client.Inputs.GetInputMute(
inputs.NewGetInputMuteParams().WithInputName(input.InputName),
)
if err != nil {
return fmt.Errorf("failed to get input mute state: %w", err)
}
muteMark = getEnabledMark(resp.InputMuted)
break
}
if cmd.Input && strings.Contains(input.InputKind, "input") {
t.AddRow(input.InputName, input.InputKind)
}
if cmd.Output && strings.Contains(input.InputKind, "output") {
t.AddRow(input.InputName, input.InputKind)
}
if cmd.Colour && strings.Contains(input.InputKind, "color") { // nolint
t.AddRow(input.InputName, input.InputKind)
}
type filter struct {
enabled bool
keyword string
}
filters := []filter{
{cmd.Input, "input"},
{cmd.Output, "output"},
{cmd.Colour, "color"}, // nolint: misspell
{cmd.Ffmpeg, "ffmpeg"},
{cmd.Vlc, "vlc"},
}
var added bool
for _, f := range filters {
if f.enabled && strings.Contains(input.InputKind, f.keyword) {
t.AddRow(input.InputName, input.InputKind, muteMark)
added = true
break
}
}
if !added && (!cmd.Input && !cmd.Output && !cmd.Colour && !cmd.Ffmpeg && !cmd.Vlc) {
t.AddRow(input.InputName, input.InputKind, muteMark)
if !cmd.Input && !cmd.Output && !cmd.Colour {
t.AddRow(input.InputName, input.InputKind)
}
}
t.Render()

140
input_test.go
View File

@ -1,140 +0,0 @@
package main
import (
"bytes"
"strings"
"testing"
)
func TestInputList(t *testing.T) {
client, disconnect := getClient(t)
defer disconnect()
var out bytes.Buffer
context := &context{
Client: client,
Out: &out,
}
cmd := &InputListCmd{}
err := cmd.Run(context)
if err != nil {
t.Fatalf("Failed to list inputs: %v", err)
}
expectedInputs := []string{
"Desktop Audio",
"Mic/Aux",
"Colour Source",
"Colour Source 2",
"Colour Source 3",
}
output := out.String()
for _, input := range expectedInputs {
if !strings.Contains(output, input) {
t.Fatalf("Expected output to contain '%s', got '%s'", input, output)
}
}
}
func TestInputListFilterInput(t *testing.T) {
client, disconnect := getClient(t)
defer disconnect()
var out bytes.Buffer
context := &context{
Client: client,
Out: &out,
}
cmd := &InputListCmd{Input: true}
err := cmd.Run(context)
if err != nil {
t.Fatalf("Failed to list inputs with filter: %v", err)
}
expectedInputs := []string{
"Mic/Aux",
}
expectedFilteredOut := []string{
"Desktop Audio",
"Colour Source",
"Colour Source 2",
"Colour Source 3",
}
for _, input := range expectedInputs {
if !strings.Contains(out.String(), input) {
t.Fatalf("Expected output to contain '%s', got '%s'", input, out.String())
}
}
for _, filteredOut := range expectedFilteredOut {
if strings.Contains(out.String(), filteredOut) {
t.Fatalf("Expected output to NOT contain '%s', got '%s'", filteredOut, out.String())
}
}
}
func TestInputListFilterOutput(t *testing.T) {
client, disconnect := getClient(t)
defer disconnect()
var out bytes.Buffer
context := &context{
Client: client,
Out: &out,
}
cmd := &InputListCmd{Output: true}
err := cmd.Run(context)
if err != nil {
t.Fatalf("Failed to list outputs with filter: %v", err)
}
expectedInputs := []string{
"Desktop Audio",
}
expectedFilteredOut := []string{
"Mic/Aux",
"Colour Source",
"Colour Source 2",
"Colour Source 3",
}
for _, input := range expectedInputs {
if !strings.Contains(out.String(), input) {
t.Fatalf("Expected output to contain '%s', got '%s'", input, out.String())
}
}
for _, filteredOut := range expectedFilteredOut {
if strings.Contains(out.String(), filteredOut) {
t.Fatalf("Expected output to NOT contain '%s', got '%s'", filteredOut, out.String())
}
}
}
func TestInputListFilterColour(t *testing.T) {
client, disconnect := getClient(t)
defer disconnect()
var out bytes.Buffer
context := &context{
Client: client,
Out: &out,
}
cmd := &InputListCmd{Colour: true}
err := cmd.Run(context)
if err != nil {
t.Fatalf("Failed to list colour inputs with filter: %v", err)
}
expectedInputs := []string{
"Colour Source",
"Colour Source 2",
"Colour Source 3",
}
for _, input := range expectedInputs {
if !strings.Contains(out.String(), input) {
t.Fatalf("Expected output to contain '%s', got '%s'", input, out.String())
}
}
}

41
main.go
View File

@ -18,10 +18,10 @@ import (
// ObsConfig holds the configuration for connecting to the OBS WebSocket server.
type ObsConfig struct {
Host string `flag:"host" help:"Host to connect to." default:"localhost" env:"OBS_HOST" short:"H"`
Port int `flag:"port" help:"Port to connect to." default:"4455" env:"OBS_PORT" short:"P"`
Password string `flag:"password" help:"Password for authentication." default:"" env:"OBS_PASSWORD" short:"p"`
Timeout int `flag:"timeout" help:"Timeout in seconds." default:"5" env:"OBS_TIMEOUT" short:"T"`
Host string `flag:"host" help:"Host to connect to." default:"localhost" env:"OBS_HOST"`
Port int `flag:"port" help:"Port to connect to." default:"4455" env:"OBS_PORT"`
Password string `flag:"password" help:"Password for authentication." default:"" env:"OBS_PASSWORD"`
Timeout int `flag:"timeout" help:"Timeout in seconds." default:"5" env:"OBS_TIMEOUT"`
}
// CLI is the main command line interface structure.
@ -29,25 +29,22 @@ type ObsConfig struct {
type CLI struct {
ObsConfig `embed:"" help:"OBS WebSocket configuration."`
Man mangokong.ManFlag `help:"Print man page."`
Version VersionFlag `help:"Print gobs-cli version information and quit" name:"version" short:"v"`
Man mangokong.ManFlag `help:"Print man page."`
ObsVersion ObsVersionCmd `help:"Print OBS client and websocket version." cmd:"" aliases:"v"`
Scene SceneCmd `help:"Manage scenes." cmd:"" aliases:"sc"`
Sceneitem SceneItemCmd `help:"Manage scene items." cmd:"" aliases:"si"`
Group GroupCmd `help:"Manage groups." cmd:"" aliases:"g"`
Input InputCmd `help:"Manage inputs." cmd:"" aliases:"i"`
Record RecordCmd `help:"Manage recording." cmd:"" aliases:"rec"`
Stream StreamCmd `help:"Manage streaming." cmd:"" aliases:"st"`
Scenecollection SceneCollectionCmd `help:"Manage scene collections." cmd:"" aliases:"scn"`
Profile ProfileCmd `help:"Manage profiles." cmd:"" aliases:"p"`
Replaybuffer ReplayBufferCmd `help:"Manage replay buffer." cmd:"" aliases:"rb"`
Studiomode StudioModeCmd `help:"Manage studio mode." cmd:"" aliases:"sm"`
Virtualcam VirtualCamCmd `help:"Manage virtual camera." cmd:"" aliases:"vc"`
Hotkey HotkeyCmd `help:"Manage hotkeys." cmd:"" aliases:"hk"`
Filter FilterCmd `help:"Manage filters." cmd:"" aliases:"f"`
Projector ProjectorCmd `help:"Manage projectors." cmd:"" aliases:"prj"`
Screenshot ScreenshotCmd `help:"Take screenshots." cmd:"" aliases:"ss"`
Version VersionCmd `help:"Show version." cmd:"" aliases:"v"`
Scene SceneCmd `help:"Manage scenes." cmd:"" aliases:"sc"`
Sceneitem SceneItemCmd `help:"Manage scene items." cmd:"" aliases:"si"`
Group GroupCmd `help:"Manage groups." cmd:"" aliases:"g"`
Input InputCmd `help:"Manage inputs." cmd:"" aliases:"i"`
Record RecordCmd `help:"Manage recording." cmd:"" aliases:"rec"`
Stream StreamCmd `help:"Manage streaming." cmd:"" aliases:"st"`
Scenecollection SceneCollectionCmd `help:"Manage scene collections." cmd:"" aliases:"scn"`
Profile ProfileCmd `help:"Manage profiles." cmd:"" aliases:"p"`
Replaybuffer ReplayBufferCmd `help:"Manage replay buffer." cmd:"" aliases:"rb"`
Studiomode StudioModeCmd `help:"Manage studio mode." cmd:"" aliases:"sm"`
Virtualcam VirtualCamCmd `help:"Manage virtual camera." cmd:"" aliases:"vc"`
Hotkey HotkeyCmd `help:"Manage hotkeys." cmd:"" aliases:"hk"`
Filter FilterCmd `help:"Manage filters." cmd:"" aliases:"f"`
}
type context struct {

35
main_test.go
View File

@ -6,10 +6,8 @@ import (
"github.com/andreykaipov/goobs"
"github.com/andreykaipov/goobs/api/requests/config"
"github.com/andreykaipov/goobs/api/requests/filters"
"github.com/andreykaipov/goobs/api/requests/inputs"
"github.com/andreykaipov/goobs/api/requests/scenes"
"github.com/andreykaipov/goobs/api/requests/ui"
typedefs "github.com/andreykaipov/goobs/api/typedefs"
)
@ -89,39 +87,9 @@ func setup(client *goobs.Client) {
"visible": true,
}).
WithSceneItemEnabled(true))
// Create source filter on an audio input
client.Filters.CreateSourceFilter(filters.NewCreateSourceFilterParams().
WithSourceName("Mic/Aux").
WithFilterName("test_filter").
WithFilterKind("compressor_filter").
WithFilterSettings(map[string]any{
"threshold": -20,
"ratio": 4,
"attack_time": 10,
"release_time": 100,
"output_gain": -3.6,
"sidechain_source": nil,
}))
// Create source filter on a scene
client.Filters.CreateSourceFilter(filters.NewCreateSourceFilterParams().
WithSourceName("gobs-test").
WithFilterName("test_filter").
WithFilterKind("luma_key_filter_v2").
WithFilterSettings(map[string]any{
"luma": 0.5,
}))
}
func teardown(client *goobs.Client) {
client.Filters.RemoveSourceFilter(filters.NewRemoveSourceFilterParams().
WithSourceName("Mic/Aux").
WithFilterName("test_filter"))
client.Filters.RemoveSourceFilter(filters.NewRemoveSourceFilterParams().
WithSourceName("gobs-test").
WithFilterName("test_filter"))
client.Scenes.RemoveScene(scenes.NewRemoveSceneParams().
WithSceneName("gobs-test"))
@ -130,7 +98,4 @@ func teardown(client *goobs.Client) {
client.Stream.StopStream()
client.Record.StopRecord()
client.Outputs.StopReplayBuffer()
client.Ui.SetStudioModeEnabled(ui.NewSetStudioModeEnabledParams().
WithStudioModeEnabled(false))
}

66
projector.go
View File

@ -1,66 +0,0 @@
package main
import (
"fmt"
"github.com/andreykaipov/goobs/api/requests/ui"
"github.com/aquasecurity/table"
)
// ProjectorCmd provides a command to manage projectors in OBS.
type ProjectorCmd struct {
ListMonitors ProjectorListMonitorsCmd `cmd:"" help:"List available monitors." aliases:"ls-m"`
Open ProjectorOpenCmd `cmd:"" help:"Open a fullscreen projector for a source on a specific monitor." aliases:"o"`
}
// ProjectorListMonitorsCmd provides a command to list all monitors available for projectors.
type ProjectorListMonitorsCmd struct{} // size = 0x0
// Run executes the command to list all monitors available for projectors.
func (cmd *ProjectorListMonitorsCmd) Run(ctx *context) error {
monitors, err := ctx.Client.Ui.GetMonitorList()
if err != nil {
return err
}
if len(monitors.Monitors) == 0 {
ctx.Out.Write([]byte("No monitors found for projectors.\n"))
return nil
}
t := table.New(ctx.Out)
t.SetPadding(3)
t.SetAlignment(table.AlignCenter, table.AlignLeft)
t.SetHeaders("Monitor ID", "Monitor Name")
for _, monitor := range monitors.Monitors {
t.AddRow(fmt.Sprintf("%d", monitor.MonitorIndex), monitor.MonitorName)
}
t.Render()
return nil
}
// ProjectorOpenCmd provides a command to open a fullscreen projector for a specific source.
type ProjectorOpenCmd struct {
MonitorIndex int `flag:"" help:"Index of the monitor to open the projector on." default:"0"`
SourceName string ` help:"Name of the source to project." default:"" arg:""`
}
// Run executes the command to show details of a specific projector.
func (cmd *ProjectorOpenCmd) Run(ctx *context) error {
if cmd.SourceName == "" {
currentScene, err := ctx.Client.Scenes.GetCurrentProgramScene()
if err != nil {
return fmt.Errorf("failed to get current program scene: %w", err)
}
cmd.SourceName = currentScene.SceneName
}
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)
return nil
}

69
record.go
View File

@ -2,19 +2,16 @@ package main
import (
"fmt"
"github.com/andreykaipov/goobs/api/requests/config"
)
// RecordCmd handles the recording commands.
type RecordCmd struct {
Start RecordStartCmd `cmd:"" help:"Start recording." aliases:"s"`
Stop RecordStopCmd `cmd:"" help:"Stop recording." aliases:"st"`
Toggle RecordToggleCmd `cmd:"" help:"Toggle recording." aliases:"tg"`
Status RecordStatusCmd `cmd:"" help:"Show recording status." aliases:"ss"`
Pause RecordPauseCmd `cmd:"" help:"Pause recording." aliases:"p"`
Resume RecordResumeCmd `cmd:"" help:"Resume recording." aliases:"r"`
Directory RecordDirectoryCmd `cmd:"" help:"Get/Set recording directory." aliases:"d"`
Start RecordStartCmd `cmd:"" help:"Start recording." aliases:"s"`
Stop RecordStopCmd `cmd:"" help:"Stop recording." aliases:"st"`
Toggle RecordToggleCmd `cmd:"" help:"Toggle recording." aliases:"tg"`
Status RecordStatusCmd `cmd:"" help:"Show recording status." aliases:"ss"`
Pause RecordPauseCmd `cmd:"" help:"Pause recording." aliases:"p"`
Resume RecordResumeCmd `cmd:"" help:"Resume recording." aliases:"r"`
}
// RecordStartCmd starts the recording.
@ -22,19 +19,7 @@ type RecordStartCmd struct{} // size = 0x0
// Run executes the command to start recording.
func (cmd *RecordStartCmd) Run(ctx *context) error {
status, err := ctx.Client.Record.GetRecordStatus()
if err != nil {
return err
}
if status.OutputActive {
if status.OutputPaused {
return fmt.Errorf("recording is already in progress and paused")
}
return fmt.Errorf("recording is already in progress")
}
_, err = ctx.Client.Record.StartRecord()
_, err := ctx.Client.Record.StartRecord()
if err != nil {
return err
}
@ -47,20 +32,11 @@ type RecordStopCmd struct{} // size = 0x0
// Run executes the command to stop recording.
func (cmd *RecordStopCmd) Run(ctx *context) error {
status, err := ctx.Client.Record.GetRecordStatus()
_, err := ctx.Client.Record.StopRecord()
if err != nil {
return err
}
if !status.OutputActive {
return fmt.Errorf("recording is not in progress")
}
resp, err := ctx.Client.Record.StopRecord()
if err != nil {
return err
}
fmt.Fprintf(ctx.Out, "%s", fmt.Sprintf("Recording stopped successfully. Output file: %s\n", resp.OutputPath))
fmt.Fprintln(ctx.Out, "Recording stopped successfully.")
return nil
}
@ -156,30 +132,3 @@ func (cmd *RecordResumeCmd) Run(ctx *context) error {
fmt.Fprintln(ctx.Out, "Recording resumed successfully.")
return nil
}
// RecordDirectoryCmd sets the recording directory.
type RecordDirectoryCmd struct {
RecordDirectory string `arg:"" help:"Directory to save recordings." default:""`
}
// Run executes the command to set the recording directory.
func (cmd *RecordDirectoryCmd) Run(ctx *context) error {
if cmd.RecordDirectory == "" {
resp, err := ctx.Client.Config.GetRecordDirectory()
if err != nil {
return err
}
fmt.Fprintf(ctx.Out, "Current recording directory: %s\n", resp.RecordDirectory)
return nil
}
_, err := ctx.Client.Config.SetRecordDirectory(
config.NewSetRecordDirectoryParams().WithRecordDirectory(cmd.RecordDirectory),
)
if err != nil {
return err
}
fmt.Fprintf(ctx.Out, "Recording directory set to: %s\n", cmd.RecordDirectory)
return nil
}

78
record_test.go
View File

@ -2,12 +2,11 @@ package main
import (
"bytes"
"strings"
"testing"
"time"
)
func TestRecordStart(t *testing.T) {
func TestRecordStartStatusStop(t *testing.T) {
client, disconnect := getClient(t)
defer disconnect()
@ -17,80 +16,51 @@ func TestRecordStart(t *testing.T) {
Out: &out,
}
cmdStatus := &RecordStatusCmd{}
err := cmdStatus.Run(context)
if err != nil {
t.Fatalf("Failed to get recording status: %v", err)
}
var active bool
if out.String() == "Recording is in progress.\n" {
active = true
}
// Reset output buffer for the next command
out.Reset()
cmdStart := &RecordStartCmd{}
err = cmdStart.Run(context)
if active {
if err == nil {
t.Fatalf("Expected error when starting recording while active, got nil")
}
if !strings.Contains(err.Error(), "recording is already in progress") {
t.Fatalf("Expected error message to contain 'recording is already in progress', got '%s'", err.Error())
}
return
}
err := cmdStart.Run(context)
if err != nil {
t.Fatalf("Failed to start recording: %v", err)
}
if out.String() != "Recording started successfully.\n" {
t.Fatalf("Expected output to contain 'Recording started successfully.', got '%s'", out.String())
t.Fatalf("Expected output to be 'Recording started successfully.', got '%s'", out.String())
}
time.Sleep(1 * time.Second) // Wait for the recording to start
}
// Reset output buffer for the next command
out.Reset()
func TestRecordStop(t *testing.T) {
client, disconnect := getClient(t)
defer disconnect()
var out bytes.Buffer
context := &context{
Client: client,
Out: &out,
}
time.Sleep(1 * time.Second) // Wait for a second to ensure recording has started
cmdStatus := &RecordStatusCmd{}
err := cmdStatus.Run(context)
err = cmdStatus.Run(context)
if err != nil {
t.Fatalf("Failed to get recording status: %v", err)
}
var active bool
if out.String() == "Recording is in progress.\n" {
active = true
if out.String() != "Recording is in progress.\n" {
t.Fatalf("Expected output to be 'Recording is in progress.', got '%s'", out.String())
}
// Reset output buffer for the next command
out.Reset()
cmdStop := &RecordStopCmd{}
err = cmdStop.Run(context)
if !active {
if err == nil {
t.Fatalf("Expected error when stopping recording while inactive, got nil")
}
if !strings.Contains(err.Error(), "recording is not in progress") {
t.Fatalf("Expected error message to contain 'recording is not in progress', got '%s'", err.Error())
}
return
}
if err != nil {
t.Fatalf("Failed to stop recording: %v", err)
}
if !strings.Contains(out.String(), "Recording stopped successfully. Output file: ") {
t.Fatalf("Expected output to contain 'Recording stopped successfully. Output file: ', got '%s'", out.String())
if out.String() != "Recording stopped successfully.\n" {
t.Fatalf("Expected output to be 'Recording stopped successfully.', got '%s'", out.String())
}
// Reset output buffer for the next command
out.Reset()
time.Sleep(1 * time.Second) // Wait for a second to ensure recording has stopped
cmdStatus = &RecordStatusCmd{}
err = cmdStatus.Run(context)
if err != nil {
t.Fatalf("Failed to get recording status: %v", err)
}
if out.String() != "Recording is not in progress.\n" {
t.Fatalf("Expected output to be 'Recording is not in progress.', got '%s'", out.String())
}
time.Sleep(1 * time.Second) // Wait for the recording to stop
}
func TestRecordToggle(t *testing.T) {

16
replaybuffer.go
View File

@ -19,11 +19,7 @@ type ReplayBufferStartCmd struct{} // size = 0x0
// Run executes the command to start the replay buffer.
func (cmd *ReplayBufferStartCmd) Run(ctx *context) error {
_, err := ctx.Client.Outputs.StartReplayBuffer()
if err != nil {
return fmt.Errorf("failed to start replay buffer: %w", err)
}
fmt.Fprintln(ctx.Out, "Replay buffer started.")
return nil
return err
}
// ReplayBufferStopCmd stops the replay buffer.
@ -32,11 +28,7 @@ type ReplayBufferStopCmd struct{} // size = 0x0
// Run executes the command to stop the replay buffer.
func (cmd *ReplayBufferStopCmd) Run(ctx *context) error {
_, err := ctx.Client.Outputs.StopReplayBuffer()
if err != nil {
return fmt.Errorf("failed to stop replay buffer: %w", err)
}
fmt.Fprintln(ctx.Out, "Replay buffer stopped.")
return nil
return err
}
// ReplayBufferToggleCmd toggles the replay buffer state.
@ -50,9 +42,9 @@ func (cmd *ReplayBufferToggleCmd) Run(ctx *context) error {
}
if status.OutputActive {
fmt.Fprintln(ctx.Out, "Replay buffer started.")
fmt.Fprintln(ctx.Out, "Replay buffer started successfully.")
} else {
fmt.Fprintln(ctx.Out, "Replay buffer stopped.")
fmt.Fprintln(ctx.Out, "Replay buffer stopped successfully.")
}
return nil
}

85
replaybuffer_test.go
View File

@ -1,85 +0,0 @@
package main
import (
"bytes"
"strings"
"testing"
)
func TestReplayBufferStart(t *testing.T) {
client, disconnect := getClient(t)
defer disconnect()
var out bytes.Buffer
context := &context{
Client: client,
Out: &out,
}
cmd := &ReplayBufferStartCmd{}
err := cmd.Run(context)
if err != nil {
t.Fatalf("Failed to start replay buffer: %v", err)
}
if out.String() != "Replay buffer started.\n" {
t.Fatalf("Expected output to be 'Replay buffer started', got '%s'", out.String())
}
}
func TestReplayBufferStop(t *testing.T) {
client, disconnect := getClient(t)
defer disconnect()
var out bytes.Buffer
context := &context{
Client: client,
Out: &out,
}
cmd := &ReplayBufferStopCmd{}
err := cmd.Run(context)
if err != nil {
t.Fatalf("Failed to stop replay buffer: %v", err)
}
if out.String() != "Replay buffer stopped.\n" {
t.Fatalf("Expected output to be 'Replay buffer stopped.', got '%s'", out.String())
}
}
func TestReplayBufferToggle(t *testing.T) {
client, disconnect := getClient(t)
defer disconnect()
var out bytes.Buffer
context := &context{
Client: client,
Out: &out,
}
cmdStatus := &ReplayBufferStatusCmd{}
err := cmdStatus.Run(context)
if err != nil {
t.Fatalf("Failed to get replay buffer status: %v", err)
}
var active bool
if strings.Contains(out.String(), "Replay buffer is active") {
active = true
}
// Reset output buffer for the next command
out.Reset()
cmdToggle := &ReplayBufferToggleCmd{}
err = cmdToggle.Run(context)
if err != nil {
t.Fatalf("Failed to toggle replay buffer: %v", err)
}
if active {
if out.String() != "Replay buffer stopped.\n" {
t.Fatalf("Expected output to be 'Replay buffer stopped.', got '%s'", out.String())
}
} else {
if out.String() != "Replay buffer started.\n" {
t.Fatalf("Expected output to be 'Replay buffer started.', got '%s'", out.String())
}
}
}

73
sceneitem.go
View File

@ -2,7 +2,6 @@ package main
import (
"fmt"
"sort"
"github.com/andreykaipov/goobs"
"github.com/andreykaipov/goobs/api/requests/sceneitems"
@ -47,57 +46,31 @@ func (cmd *SceneItemListCmd) Run(ctx *context) error {
t := table.New(ctx.Out)
t.SetPadding(3)
t.SetAlignment(table.AlignCenter, table.AlignLeft, table.AlignCenter, table.AlignCenter)
t.SetHeaders("Item ID", "Item Name", "In Group", "Enabled")
sort.Slice(resp.SceneItems, func(i, j int) bool {
return resp.SceneItems[i].SceneItemID < resp.SceneItems[j].SceneItemID
})
t.SetAlignment(table.AlignLeft)
t.SetHeaders("Item Name")
for _, item := range resp.SceneItems {
if item.IsGroup {
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)
}
sort.Slice(resp.SceneItems, func(i, j int) bool {
return resp.SceneItems[i].SceneItemID < resp.SceneItems[j].SceneItemID
})
for _, groupItem := range resp.SceneItems {
t.AddRow(
fmt.Sprintf("%d", groupItem.SceneItemID),
groupItem.SourceName,
item.SourceName,
getEnabledMark(item.SceneItemEnabled && groupItem.SceneItemEnabled),
)
}
} else {
t.AddRow(fmt.Sprintf("%d", item.SceneItemID), item.SourceName, "", getEnabledMark(item.SceneItemEnabled))
}
t.AddRow(item.SourceName)
}
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,
sceneName string,
itemName string,
group string,
parent string,
) (string, int, error) {
if group != "" {
if parent != "" {
resp, err := client.SceneItems.GetGroupSceneItemList(sceneitems.NewGetGroupSceneItemListParams().
WithSceneName(group))
WithSceneName(parent))
if err != nil {
return "", 0, err
}
for _, item := range resp.SceneItems {
if item.SourceName == itemName {
return group, int(item.SceneItemID), nil
return parent, int(item.SceneItemID), nil
}
}
return "", 0, fmt.Errorf("item '%s' not found in scene '%s'", itemName, sceneName)
@ -114,7 +87,7 @@ func getSceneNameAndItemID(
// SceneItemShowCmd provides a command to show a scene item.
type SceneItemShowCmd struct {
Group string `flag:"" help:"Parent group name."`
Parent string `flag:"" help:"Parent group name."`
SceneName string `arg:"" help:"Scene name."`
ItemName string `arg:"" help:"Item name."`
@ -122,7 +95,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.Client, cmd.SceneName, cmd.ItemName, cmd.Parent)
if err != nil {
return err
}
@ -135,8 +108,8 @@ func (cmd *SceneItemShowCmd) Run(ctx *context) error {
return err
}
if cmd.Group != "" {
fmt.Fprintf(ctx.Out, "Scene item '%s' in group '%s' is now visible.\n", cmd.ItemName, cmd.Group)
if cmd.Parent != "" {
fmt.Fprintf(ctx.Out, "Scene item '%s' in group '%s' is now visible.\n", cmd.ItemName, cmd.Parent)
} else {
fmt.Fprintf(ctx.Out, "Scene item '%s' in scene '%s' is now visible.\n", cmd.ItemName, cmd.SceneName)
}
@ -146,7 +119,7 @@ func (cmd *SceneItemShowCmd) Run(ctx *context) error {
// SceneItemHideCmd provides a command to hide a scene item.
type SceneItemHideCmd struct {
Group string `flag:"" help:"Parent group name."`
Parent string `flag:"" help:"Parent group name."`
SceneName string `arg:"" help:"Scene name."`
ItemName string `arg:"" help:"Item name."`
@ -154,7 +127,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.Client, cmd.SceneName, cmd.ItemName, cmd.Parent)
if err != nil {
return err
}
@ -167,8 +140,8 @@ func (cmd *SceneItemHideCmd) Run(ctx *context) error {
return err
}
if cmd.Group != "" {
fmt.Fprintf(ctx.Out, "Scene item '%s' in group '%s' is now hidden.\n", cmd.ItemName, cmd.Group)
if cmd.Parent != "" {
fmt.Fprintf(ctx.Out, "Scene item '%s' in group '%s' is now hidden.\n", cmd.ItemName, cmd.Parent)
} else {
fmt.Fprintf(ctx.Out, "Scene item '%s' in scene '%s' is now hidden.\n", cmd.ItemName, cmd.SceneName)
}
@ -189,7 +162,7 @@ func getItemEnabled(client *goobs.Client, sceneName string, itemID int) (bool, e
// SceneItemToggleCmd provides a command to toggle the visibility of a scene item.
type SceneItemToggleCmd struct {
Group string `flag:"" help:"Parent group name."`
Parent string `flag:"" help:"Parent group name."`
SceneName string `arg:"" help:"Scene name."`
ItemName string `arg:"" help:"Item name."`
@ -197,7 +170,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.Client, cmd.SceneName, cmd.ItemName, cmd.Parent)
if err != nil {
return err
}
@ -226,7 +199,7 @@ func (cmd *SceneItemToggleCmd) Run(ctx *context) error {
// SceneItemVisibleCmd provides a command to check the visibility of a scene item.
type SceneItemVisibleCmd struct {
Group string `flag:"" help:"Parent group name."`
Parent string `flag:"" help:"Parent group name."`
SceneName string `arg:"" help:"Scene name."`
ItemName string `arg:"" help:"Item name."`
@ -234,7 +207,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.Client, cmd.SceneName, cmd.ItemName, cmd.Parent)
if err != nil {
return err
}
@ -257,7 +230,7 @@ type SceneItemTransformCmd struct {
SceneName string `arg:"" help:"Scene name."`
ItemName string `arg:"" help:"Item name."`
Group string `flag:"" help:"Parent group name."`
Parent string `flag:"" help:"Parent group name."`
Alignment float64 `flag:"" help:"Alignment of the scene item."`
BoundsAlignment float64 `flag:"" help:"Bounds alignment of the scene item."`
@ -278,7 +251,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.Client, cmd.SceneName, cmd.ItemName, cmd.Parent)
if err != nil {
return err
}
@ -350,8 +323,8 @@ func (cmd *SceneItemTransformCmd) Run(ctx *context) error {
return err
}
if cmd.Group != "" {
fmt.Fprintf(ctx.Out, "Scene item '%s' in group '%s' transformed.\n", cmd.ItemName, cmd.Group)
if cmd.Parent != "" {
fmt.Fprintf(ctx.Out, "Scene item '%s' in group '%s' transformed.\n", cmd.ItemName, cmd.Parent)
} else {
fmt.Fprintf(ctx.Out, "Scene item '%s' in scene '%s' transformed.\n", cmd.ItemName, cmd.SceneName)
}

41
screenshot.go
View File

@ -1,41 +0,0 @@
package main
import (
"fmt"
"path/filepath"
"github.com/andreykaipov/goobs/api/requests/sources"
)
// ScreenshotCmd provides commands to manage screenshots in OBS Studio.
type ScreenshotCmd struct {
Save ScreenshotSaveCmd `cmd:"" help:"Take a screenshot and save it to a file." aliases:"sv"`
}
// ScreenshotSaveCmd represents the command to save a screenshot of a source in OBS.
type ScreenshotSaveCmd struct {
SourceName string `arg:"" help:"Name of the source to take a screenshot of."`
FilePath string `arg:"" help:"Path to the file where the screenshot will be saved."`
Width float64 ` help:"Width of the screenshot in pixels." flag:"" default:"1920"`
Height float64 ` help:"Height of the screenshot in pixels." flag:"" default:"1080"`
Quality float64 ` help:"Quality of the screenshot (1-100)." flag:"" default:"-1"`
}
// Run executes the command to take a screenshot and save it to a file.
func (cmd *ScreenshotSaveCmd) Run(ctx *context) error {
_, err := ctx.Client.Sources.SaveSourceScreenshot(
sources.NewSaveSourceScreenshotParams().
WithSourceName(cmd.SourceName).
WithImageFormat(trimPrefix(filepath.Ext(cmd.FilePath), ".")).
WithImageFilePath(cmd.FilePath).
WithImageWidth(cmd.Width).
WithImageHeight(cmd.Height).
WithImageCompressionQuality(cmd.Quality),
)
if err != nil {
return fmt.Errorf("failed to take screenshot: %w", err)
}
fmt.Fprintf(ctx.Out, "Screenshot saved to %s.\n", cmd.FilePath)
return nil
}

14
stream.go
View File

@ -23,7 +23,8 @@ func (cmd *StreamStartCmd) Run(ctx *context) error {
return err
}
if status.OutputActive {
return fmt.Errorf("stream is already in progress")
fmt.Fprintln(ctx.Out, "Stream is already active.")
return nil
}
_, err = ctx.Client.Stream.StartStream()
@ -31,7 +32,7 @@ func (cmd *StreamStartCmd) Run(ctx *context) error {
return err
}
fmt.Fprintln(ctx.Out, "Stream started successfully.")
fmt.Fprintln(ctx.Out, "Streaming started successfully.")
return nil
}
@ -46,7 +47,8 @@ func (cmd *StreamStopCmd) Run(ctx *context) error {
return err
}
if !status.OutputActive {
return fmt.Errorf("stream is not in progress")
fmt.Fprintln(ctx.Out, "Stream is already inactive.")
return nil
}
_, err = ctx.Client.Stream.StopStream()
@ -54,7 +56,7 @@ func (cmd *StreamStopCmd) Run(ctx *context) error {
return err
}
fmt.Fprintln(ctx.Out, "Stream stopped successfully.")
fmt.Fprintln(ctx.Out, "Streaming stopped successfully.")
return nil
}
@ -69,9 +71,9 @@ func (cmd *StreamToggleCmd) Run(ctx *context) error {
}
if status.OutputActive {
fmt.Fprintln(ctx.Out, "Stream started successfully.")
fmt.Fprintln(ctx.Out, "Streaming started successfully.")
} else {
fmt.Fprintln(ctx.Out, "Stream stopped successfully.")
fmt.Fprintln(ctx.Out, "Streaming stopped successfully.")
}
return nil
}

57
stream_test.go
View File

@ -31,22 +31,21 @@ func TestStreamStart(t *testing.T) {
cmdStart := &StreamStartCmd{}
err = cmdStart.Run(context)
if active {
if err == nil {
t.Fatalf("Expected error when starting stream while active, got nil")
}
if !strings.Contains(err.Error(), "stream is already in progress") {
t.Fatalf("Expected error message to contain 'stream is already in progress', got '%s'", err.Error())
}
return
}
if err != nil {
t.Fatalf("Failed to start stream: %v", err)
}
if out.String() != "Stream started successfully.\n" {
t.Fatalf("Expected output to contain 'Stream started successfully.', got '%s'", out.String())
time.Sleep(1 * time.Second) // Wait for the stream to start
if active {
if out.String() != "Stream is already active.\n" {
t.Fatalf("Expected 'Stream is already active.', got: %s", out.String())
}
} else {
if out.String() != "Streaming started successfully.\n" {
t.Fatalf("Expected 'Streaming started successfully.', got: %s", out.String())
}
}
time.Sleep(2 * time.Second) // Wait for the stream to start
}
func TestStreamStop(t *testing.T) {
@ -73,22 +72,21 @@ func TestStreamStop(t *testing.T) {
cmdStop := &StreamStopCmd{}
err = cmdStop.Run(context)
if !active {
if err == nil {
t.Fatalf("Expected error when stopping stream while inactive, got nil")
}
if !strings.Contains(err.Error(), "stream is not in progress") {
t.Fatalf("Expected error message to contain 'stream is not in progress', got '%s'", err.Error())
}
return
}
if err != nil {
t.Fatalf("Failed to stop stream: %v", err)
}
if out.String() != "Stream stopped successfully.\n" {
t.Fatalf("Expected output to contain 'Stream stopped successfully.', got '%s'", out.String())
time.Sleep(1 * time.Second) // Wait for the stream to stop
if active {
if out.String() != "Streaming stopped successfully.\n" {
t.Fatalf("Expected 'Streaming stopped successfully.', got: %s", out.String())
}
} else {
if out.String() != "Stream is already inactive.\n" {
t.Fatalf("Expected 'Stream is already inactive.', got: %s", out.String())
}
}
time.Sleep(2 * time.Second) // Wait for the stream to stop
}
func TestStreamToggle(t *testing.T) {
@ -119,14 +117,15 @@ func TestStreamToggle(t *testing.T) {
t.Fatalf("Failed to toggle stream: %v", err)
}
time.Sleep(1 * time.Second) // Wait for the stream to toggle
if active {
if out.String() != "Stream stopped successfully.\n" {
t.Fatalf("Expected 'Stream stopped successfully.', got: %s", out.String())
if out.String() != "Streaming stopped successfully.\n" {
t.Fatalf("Expected 'Streaming stopped successfully.', got: %s", out.String())
}
} else {
if out.String() != "Stream started successfully.\n" {
t.Fatalf("Expected 'Stream started successfully.', got: %s", out.String())
if out.String() != "Streaming started successfully.\n" {
t.Fatalf("Expected 'Streaming started successfully.', got: %s", out.String())
}
}
time.Sleep(2 * time.Second) // Wait for the stream to toggle
}

7
util.go
View File

@ -20,10 +20,3 @@ func getEnabledMark(enabled bool) string {
}
return "\u274c" // red cross mark
}
func trimPrefix(s, prefix string) string {
if strings.HasPrefix(s, prefix) {
return s[len(prefix):]
}
return s
}

36
version.go
View File

@ -2,43 +2,13 @@ package main
import (
"fmt"
"runtime/debug"
"strings"
"github.com/alecthomas/kong"
)
var version string
// VersionFlag is a custom flag type for displaying version information.
type VersionFlag string
// Decode implements the kong.Flag interface for VersionFlag.
func (v VersionFlag) Decode(_ *kong.DecodeContext) error { return nil }
// IsBool implements the kong.Flag interface for VersionFlag.
func (v VersionFlag) IsBool() bool { return true }
// BeforeApply implements the kong.Flag interface for VersionFlag.
func (v VersionFlag) BeforeApply(app *kong.Kong, _ kong.Vars) error { // nolint: unparam
if version == "" {
info, ok := debug.ReadBuildInfo()
if !ok {
return fmt.Errorf("failed to read build info")
}
version = strings.Split(info.Main.Version, "-")[0]
}
fmt.Printf("gobs-cli version: %s\n", version)
app.Exit(0) // Exit the application after printing the version
return nil
}
// ObsVersionCmd handles the version command.
type ObsVersionCmd struct{} // size = 0x0
// VersionCmd handles the version command.
type VersionCmd struct{} // size = 0x0
// Run executes the command to get the OBS client version.
func (cmd *ObsVersionCmd) Run(ctx *context) error {
func (cmd *VersionCmd) Run(ctx *context) error {
version, err := ctx.Client.General.GetVersion()
if err != nil {
return err

30
version_test.go
View File

@ -1,30 +0,0 @@
package main
import (
"bytes"
"strings"
"testing"
)
func TestVersion(t *testing.T) {
client, disconnect := getClient(t)
defer disconnect()
var out bytes.Buffer
context := &context{
Client: client,
Out: &out,
}
cmd := &ObsVersionCmd{}
err := cmd.Run(context)
if err != nil {
t.Fatalf("Failed to get version: %v", err)
}
if !strings.Contains(out.String(), "OBS Client Version:") {
t.Fatalf("Expected output to contain 'OBS Client Version:', got '%s'", out.String())
}
if !strings.Contains(out.String(), "with Websocket Version:") {
t.Fatalf("Expected output to contain 'with Websocket Version:', got '%s'", out.String())
}
}