feat(cli): add monit-agent catalog|invoke subcommands

Two-step on-box diagnostics surface: `catalog` discovers tools per
target via /monit/tools/catalog, `invoke` runs up to 8 of them
concurrently via /monit/tools/invoke. --tool-spec uses StringArray so
params=<json> bodies with commas survive intact.

Side-fix: extend test-helper resetFlagSet to also clear stringSlice
and stringArray flags between execCommand calls; without it, a later
test sees leftover repeated --flag entries from earlier ones.

Author: ysyneu

internal/cli/command_test.go

@@ -295,6 +295,15 @@ func (m *mockClient) MonitQueryRows(context.Context, *flashduty.MonitQueryRowsIn
 	return nil, fmt.Errorf("mockClient: MonitQueryRows not implemented")
 }
 
+// CLI Phase 2: monit-agent
+func (m *mockClient) MonitAgentCatalog(context.Context, *flashduty.MonitAgentCatalogInput) (*flashduty.MonitAgentCatalogOutput, error) {
+	return nil, fmt.Errorf("mockClient: MonitAgentCatalog not implemented")
+}
+
+func (m *mockClient) MonitAgentInvoke(context.Context, *flashduty.MonitAgentInvokeInput) (*flashduty.MonitAgentInvokeOutput, error) {
+	return nil, fmt.Errorf("mockClient: MonitAgentInvoke not implemented")
+}
+
 // saveAndResetGlobals saves the current state of all global vars that commands
 // mutate, resets them to safe defaults, and returns a restore function for
 // t.Cleanup.
@@ -365,6 +374,16 @@ func resetFlagSet(flags *pflag.FlagSet) {
 		case "bool", "int", "int64", "string":
 			_ = flag.Value.Set(flag.DefValue)
 			flag.Changed = false
+		case "stringSlice", "stringArray":
+			// Slice-valued flags accumulate across Parse() calls; clear them
+			// explicitly so a later test isn't observing the previous test's
+			// repeated --flag entries. pflag's SliceValue / Append interfaces
+			// don't expose a "reset to default" — Set("") would append an
+			// empty entry, so we use Replace([]) to truly empty the slice.
+			if sv, ok := flag.Value.(pflag.SliceValue); ok {
+				_ = sv.Replace([]string{})
+				flag.Changed = false
+			}
 		}
 	})
 }

internal/cli/helpers.go

@@ -1,8 +1,11 @@
 package cli
 
 import (
+	"encoding/json"
 	"fmt"
 	"strings"
+
+	flashduty "github.com/flashcatcloud/flashduty-sdk"
 )
 
 // parseKVSlice converts a slice of "KEY=VALUE" entries into a map.
@@ -22,3 +25,37 @@ func parseKVSlice(entries []string) (map[string]string, error) {
 	}
 	return out, nil
 }
+
+// parseToolSpecs converts a slice of "name=<tool>[,params=<json>]" specs into
+// MonitAgentInvokeTool entries. The `name` key is required; `params` is
+// optional and defaults to `{}` so the server-side decoder accepts it. Splits
+// each spec on ',' first then on the first '=', mirroring parseKVSlice — that
+// means params JSON containing commas isn't supported; specs with complex
+// params must keep their objects single-keyed.
+func parseToolSpecs(specs []string) ([]flashduty.MonitAgentInvokeTool, error) {
+	out := make([]flashduty.MonitAgentInvokeTool, 0, len(specs))
+	for _, s := range specs {
+		var name string
+		params := json.RawMessage("{}")
+		for _, kv := range strings.Split(s, ",") {
+			i := strings.IndexByte(kv, '=')
+			if i < 0 {
+				return nil, fmt.Errorf("missing '=' in %q", kv)
+			}
+			k, v := kv[:i], kv[i+1:]
+			switch k {
+			case "name":
+				name = v
+			case "params":
+				params = json.RawMessage(v)
+			default:
+				return nil, fmt.Errorf("unknown key %q in tool-spec", k)
+			}
+		}
+		if name == "" {
+			return nil, fmt.Errorf("missing name= in spec %q", s)
+		}
+		out = append(out, flashduty.MonitAgentInvokeTool{Tool: name, Params: params})
+	}
+	return out, nil
+}

internal/cli/monit_agent.go

@@ -0,0 +1,96 @@
+package cli
+
+import (
+	"fmt"
+
+	flashduty "github.com/flashcatcloud/flashduty-sdk"
+	"github.com/spf13/cobra"
+)
+
+func newMonitAgentCmd() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "monit-agent",
+		Short: "On-box diagnostics via flashmonit agents (host/mysql/redis/…)",
+	}
+	cmd.AddCommand(newMonitAgentCatalogCmd())
+	cmd.AddCommand(newMonitAgentInvokeCmd())
+	return cmd
+}
+
+func newMonitAgentCatalogCmd() *cobra.Command {
+	var targetKind, targetLocator string
+
+	cmd := &cobra.Command{
+		Use:   "catalog",
+		Short: "List the diagnostic tools the agent exposes for a target",
+		RunE: func(cmd *cobra.Command, args []string) error {
+			if targetLocator == "" {
+				return fmt.Errorf("--target-locator is required")
+			}
+			return runCommand(cmd, args, func(ctx *RunContext) error {
+				input := &flashduty.MonitAgentCatalogInput{
+					TargetKind:    targetKind,
+					TargetLocator: targetLocator,
+				}
+				result, err := ctx.Client.MonitAgentCatalog(cmdContext(ctx.Cmd), input)
+				if err != nil {
+					return err
+				}
+				return ctx.Printer.Print(result, nil)
+			})
+		},
+	}
+
+	cmd.Flags().StringVar(&targetKind, "target-kind", "", "Target kind (host|mysql|redis|…); omit to let the agent infer")
+	cmd.Flags().StringVar(&targetLocator, "target-locator", "", "Target locator: internal IP, hostname, or data-source name (required)")
+
+	return cmd
+}
+
+func newMonitAgentInvokeCmd() *cobra.Command {
+	var (
+		targetKind, targetLocator string
+		toolSpecs                 []string
+	)
+
+	cmd := &cobra.Command{
+		Use:   "invoke",
+		Short: "Run up to 8 monit-agent tools concurrently on a target",
+		RunE: func(cmd *cobra.Command, args []string) error {
+			if targetLocator == "" {
+				return fmt.Errorf("--target-locator is required")
+			}
+			if len(toolSpecs) == 0 {
+				return fmt.Errorf("--tool-spec is required (repeatable; up to 8)")
+			}
+			if len(toolSpecs) > 8 {
+				return fmt.Errorf("--tool-spec accepts up to 8 entries (got %d)", len(toolSpecs))
+			}
+			parsed, err := parseToolSpecs(toolSpecs)
+			if err != nil {
+				return fmt.Errorf("invalid --tool-spec: %w", err)
+			}
+
+			return runCommand(cmd, args, func(ctx *RunContext) error {
+				input := &flashduty.MonitAgentInvokeInput{
+					TargetKind:    targetKind,
+					TargetLocator: targetLocator,
+					Tools:         parsed,
+				}
+				result, err := ctx.Client.MonitAgentInvoke(cmdContext(ctx.Cmd), input)
+				if err != nil {
+					return err
+				}
+				return ctx.Printer.Print(result, nil)
+			})
+		},
+	}
+
+	cmd.Flags().StringVar(&targetKind, "target-kind", "", "Target kind (host|mysql|redis|…); omit to let the agent infer")
+	cmd.Flags().StringVar(&targetLocator, "target-locator", "", "Target locator: internal IP, hostname, or data-source name (required)")
+	// Use StringArray (not StringSlice) so commas inside params=<json> aren't
+	// mis-parsed as CSV separators — each --tool-spec entry is taken verbatim.
+	cmd.Flags().StringArrayVar(&toolSpecs, "tool-spec", nil, "Tool spec 'name=<tool>[,params=<json>]' (repeatable, max 8)")
+
+	return cmd
+}