shell: return flag parse errors from every command (#12618)

* shell: return flag parse errors from every command

48 commands returned nil when their flags failed to parse, so a mistyped
flag printed the flag error but the command still counted as a success:
a piped weed shell run exited 0, the master maintenance loop logged no
error, and admin script jobs reported the line as done.

Return the parse error as s3.bucket.create (#12544) and the other shell
commands already do. TestCommandsReturnFlagParseErrors runs every
registered command with an unknown flag and fails for the 48 on master.

Signed-off-by: anant <170962632+antcybersec@users.noreply.github.com>

* shell: don't report -h as a failure

With the parse errors returned, -h on those commands now returns
flag.ErrHelp, so the shell printed "error: flag: help requested" and a
piped run exited 1. The flag package has already printed the usage, so
processEachCmd now treats flag.ErrHelp as success for every command.

Signed-off-by: anant <170962632+antcybersec@users.noreply.github.com>

* shell: keep the -h test beside the flag parse test

TestProcessEachCmdTreatsHelpAsSuccess covers the same change as
TestCommandsReturnFlagParseErrors, so it lives in the same new file and
shell_liner_test.go stays as it was.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

---------

Signed-off-by: anant <170962632+antcybersec@users.noreply.github.com>
Co-authored-by: anant <170962632+antcybersec@users.noreply.github.com>
Co-authored-by: Chris Lu <chrislusf@users.noreply.github.com>
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>

weed/shell/command_flag_parse_test.go

@@ -0,0 +1,51 @@
+package shell
+
+import (
+	"bytes"
+	"flag"
+	"strings"
+	"testing"
+)
+
+// A command that parses flags must report a bad flag as an error. Returning
+// nil makes a typo in a weed shell script or a master maintenance script look
+// like a successful run that did nothing.
+func TestCommandsReturnFlagParseErrors(t *testing.T) {
+	for _, c := range Commands {
+		t.Run(c.Name(), func(t *testing.T) {
+			// fs.meta.load parses every argument but the last as flags.
+			err, needsEnv := doWithoutCommandEnv(c, []string{"-notAFlagOfAnyCommand", "arg"})
+			if needsEnv {
+				t.Skip("uses the command environment before parsing any flags")
+			}
+			if err == nil {
+				t.Fatal("an unknown flag was reported as success")
+			}
+			if !strings.Contains(err.Error(), "flag provided but not defined") {
+				t.Skipf("rejects its arguments without parsing flags: %v", err)
+			}
+		})
+	}
+}
+
+// doWithoutCommandEnv runs c with a nil CommandEnv. A command that panics here
+// used the environment before parsing flags, or takes no flags at all.
+func doWithoutCommandEnv(c command, args []string) (err error, needsEnv bool) {
+	defer func() {
+		if recover() != nil {
+			needsEnv = true
+		}
+	}()
+	var out bytes.Buffer
+	return c.Do(args, nil, &out), false
+}
+
+func TestProcessEachCmdTreatsHelpAsSuccess(t *testing.T) {
+	Commands = append(Commands, &fakeCommand{name: "test.help.command", err: flag.ErrHelp})
+	t.Cleanup(func() { Commands = Commands[:len(Commands)-1] })
+
+	exit, err := processEachCmd("test.help.command -h", nil)
+	if exit || err != nil {
+		t.Errorf("-h must not count as a failure, got exit=%v err=%v", exit, err)
+	}
+}