io shaping: detect missing subcommand and surface friendly message

On EOS instances that ship without the io shaping subcommand
(e.g. eosaliceo2-ns-02), `eos io shaping ls` exits 22 and dumps the
generic `io stat` / `io enable` usage block on stdout. We were
wrapping that as an error and rendering it verbatim in the IO Traffic
view, which buried the actual cause under a wall of unrelated help
text.

Detect the pattern (exit status 22 + usage block that omits any mention
of shaping) and return a sentinel ErrIOShapingUnsupported. The view
checks for it via errors.Is and renders a short, actionable message
instead of the raw output.

Author: lobis

eos/fetch_ioshaping.go

@@ -3,11 +3,38 @@ package eos
 import (
 	"context"
 	"encoding/json"
+	"errors"
 	"fmt"
 	"strconv"
 	"strings"
 )
 
+// ErrIOShapingUnsupported is returned when the connected EOS instance does
+// not implement the `io shaping` subcommand at all (older builds expose only
+// `io stat` / `io enable`). Callers can surface a friendly message instead
+// of dumping the raw usage text.
+var ErrIOShapingUnsupported = errors.New("io shaping is not supported by this EOS version")
+
+// looksUnsupported recognises the response that EOS gives when an unknown
+// `io` subcommand is supplied: exit status 22 plus a usage block that lists
+// the supported `io` subcommands but does not mention `shaping`.
+func looksUnsupported(err error, output []byte) bool {
+	if err == nil {
+		return false
+	}
+	if !strings.Contains(err.Error(), "exit status 22") {
+		return false
+	}
+	text := string(output)
+	if !strings.Contains(text, "usage:") {
+		return false
+	}
+	// The genuine `io shaping` usage text starts with `io shaping`. The
+	// fallback usage that EOS prints for an unknown subcommand starts with
+	// `io stat` / `io enable` and never names `shaping`.
+	return !strings.Contains(text, "io shaping") && !strings.Contains(text, "io_shaping")
+}
+
 func (c *Client) IOShaping(ctx context.Context, mode IOShapingMode) ([]IOShapingRecord, error) {
 	flag := "--apps"
 	switch mode {
@@ -18,6 +45,9 @@ func (c *Client) IOShaping(ctx context.Context, mode IOShapingMode) ([]IOShaping
 	}
 	output, err := c.runCommandContext(ctx, "eos", "io", "shaping", "ls", flag, "--json", "--window", "5")
 	if err != nil {
+		if looksUnsupported(err, output) {
+			return nil, ErrIOShapingUnsupported
+		}
 		return nil, fmt.Errorf("io shaping ls: %w: %s", err, strings.TrimSpace(string(output)))
 	}
 
@@ -52,6 +82,9 @@ func (c *Client) IOShaping(ctx context.Context, mode IOShapingMode) ([]IOShaping
 func (c *Client) IOShapingPolicies(ctx context.Context) ([]IOShapingPolicyRecord, error) {
 	output, err := c.runCommandContext(ctx, "eos", "io", "shaping", "policy", "ls", "--json")
 	if err != nil {
+		if looksUnsupported(err, output) {
+			return nil, ErrIOShapingUnsupported
+		}
 		return nil, fmt.Errorf("io shaping policy ls: %w: %s", err, strings.TrimSpace(string(output)))
 	}
 

eos/fetch_ioshaping_test.go

@@ -0,0 +1,38 @@
+package eos
+
+import (
+	"errors"
+	"testing"
+)
+
+func TestLooksUnsupported(t *testing.T) {
+	// Real-world output from eosaliceo2-ns-02 when running `eos io shaping ls`:
+	// EOS doesn't recognise `shaping` so it dumps the help text for the
+	// supported `io` subcommands (`stat`, `enable`, ...) and exits 22.
+	unknownSubcmdHelp := []byte(`usage:
+io stat [-l] [-a] [-m] [-n] [-t] [-d] [-x] [--ss] [--sa] [--si] : print io statistics
+    -l : show summary information (this is the default if -a,-t,-d,-x is not selected)
+io enable [-r] [-p] [-n] [--udp <address>] : enable collection of io statistics
+io disable [-r] [-p] [-n] [--udp <address>] : disable collection of io statistics
+`)
+
+	cases := []struct {
+		name   string
+		err    error
+		output []byte
+		want   bool
+	}{
+		{"nil error", nil, unknownSubcmdHelp, false},
+		{"exit 22 + unknown subcommand help", errors.New("exit status 22"), unknownSubcmdHelp, true},
+		{"exit 22 wrapping help with shaping mention", errors.New("exit status 22"), []byte("usage: io shaping ls --json"), false},
+		{"exit 1 + same help text", errors.New("exit status 1"), unknownSubcmdHelp, false},
+		{"exit 22 + unrelated message", errors.New("exit status 22"), []byte("permission denied"), false},
+	}
+	for _, tt := range cases {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := looksUnsupported(tt.err, tt.output); got != tt.want {
+				t.Fatalf("looksUnsupported = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}

ui/view_io_shaping.go

@@ -1,6 +1,7 @@
 package ui
 
 import (
+	"errors"
 	"fmt"
 	"sort"
 	"strings"
@@ -66,10 +67,14 @@ func (m model) renderIOShapingView(height int) string {
 	}
 
 	if m.ioShapingErr != nil {
+		message := m.ioShapingErr.Error()
+		if errors.Is(m.ioShapingErr, eos.ErrIOShapingUnsupported) {
+			message = "IO traffic shaping is not available on this EOS instance.\nThe `io shaping` subcommand is missing — check `eos io --help` on the MGM."
+		}
 		lines := []string{
 			m.styles.label.Render("IO Traffic Shaping") + indicator,
 			"",
-			m.styles.error.Render(m.ioShapingErr.Error()),
+			m.styles.error.Render(message),
 		}
 		return m.styles.panelDim.Width(width).Render(fitLines(lines, height))
 	}