go-cli-request-error-usage-suppression

Answer

1. internal/builtin/request.go — stop dumping usage on runtime errors

The root cause: cobra prints the full usage block for any error from RunE/ParseFlags/ValidateArgs by default. HTTP 404/500 are runtime failures, not usage mistakes, so they must print the server body/error only. The fix uses three cobra features:

// internal/builtin/root.go
func newRootCmd() *cobra.Command {
    root := &cobra.Command{
        Use:           "openapi-cli",
        SilenceUsage:  true,  // runtime errors never dump the usage block
        SilenceErrors: true,  // commands already wrote the error to stderr
    }
    // Usage prints ONLY for genuine flag misuse (unknown/malformed flags).
    root.SetFlagErrorFunc(func(c *cobra.Command, err error) error {
        c.PrintErrln("Error:", err.Error())
        c.PrintErrln()
        c.PrintErrln(c.UsageString())
        return err
    })
    root.AddCommand(newRequestCmd())
    return root
}

// usageArgs wraps a positional-args validator so wrong arity also prints
// the usage block (flag/arg misuse) — then returns the error for exit code 1.
func usageArgs(min, max int, name string) cobra.PositionalArgs {
    return func(cmd *cobra.Command, args []string) error {
        if len(args) < min || (max >= 0 && len(args) > max) {
            fmt.Fprintf(cmd.ErrOrStderr(),
                "Error: %s accepts %d arg(s), received %d\n\n", name, min, len(args))
            fmt.Fprint(cmd.ErrOrStderr(), cmd.UsageString())
            return fmt.Errorf("%s accepts %d arg(s), received %d", name, min, len(args))
        }
        return nil
    }
}

func newRequestCmd() *cobra.Command {
    cmd := &cobra.Command{
        Use:   "request <url>",
        Short: "Send an HTTP request and print the response body",
        Args:  usageArgs(1, 1, "request"),
        RunE: func(cmd *cobra.Command, args []string) error {
            url := args[0]
            method, _ := cmd.Flags().GetString("method")
            timeout, _ := cmd.Flags().GetDuration("timeout")

            resp, err := (&http.Client{Timeout: timeout}).Do(
                mustMethod(method), url)  // http.NewRequest(...)
            if err != nil {
                return fmt.Errorf("request: %w", err)
            }
            defer resp.Body.Close()
            body, _ := io.ReadAll(resp.Body)

            // Runtime outcome: print status + server body to stderr, NEVER usage.
            fmt.Fprintln(cmd.ErrOrStderr(), "status:", resp.StatusCode)
            if resp.StatusCode >= 400 {
                fmt.Fprintln(cmd.ErrOrStderr(), "server body:", strings.TrimSpace(string(body)))
                return errors.New("request failed")
            }
            cmd.Println(string(body))
            return nil
        },
    }
    cmd.Flags().StringP("method", "X", "GET", "HTTP method")
    cmd.Flags().Duration("timeout", 10*time.Second, "request timeout")
    return cmd
}

main() just calls root.Execute() and exits non-zero on error — nothing prints there, because errors were already rendered by the command layer.

2. pkg/dsl/interpreter.go — --verbose gate + stdout print sink

The interpreter dumped every variable binding and routed print() through the INF logger. The fix adds a PrintFunc stdout sink (defaulting to os.Stdout) and gates the post-run binding dump behind Verbose:

// pkg/dsl/interpreter.go
type Interpreter struct {
    PrintFunc func(string) error // sink for DSL print(); defaults to os.Stdout
    Verbose   bool               // dump bindings/trace after script end
}

func NewInterpreter(opts ...Option) *Interpreter {
    in := &Interpreter{PrintFunc: func(s string) error {
        _, err := fmt.Fprintln(os.Stdout, s) // legacy default: real stdout
        return err
    }}
    for _, o := range opts {
        o(in)
    }
    return in
}

func (in *Interpreter) Run(script *ast.Script) error {
    // ... execute statements ...
    if stmt, ok := node.(*ast.PrintStmt); ok {
        if err := in.PrintFunc(fmt.Sprint(stmt.Value.Eval(env))); err != nil {
            return err // PrintFunc errors propagate to the CLI
        }
    }
    // Old code: env.Dump() unconditionally + INF lines.
    if in.Verbose {
        in.dumpBindings(env) // only with --verbose
    }
    return nil
}

The dsl run command wires it up:

// internal/builtin/dsl.go
runCmd := &cobra.Command{
    Use:   "run <script.dsl>",
    Short: "Execute a DSL script",
    Args:  usageArgs(1, 1, "run"),
    RunE: func(cmd *cobra.Command, args []string) error {
        verbose, _ := cmd.Flags().GetBool("verbose")
        interp := dsl.NewInterpreter(dsl.WithPrintFunc(func(s string) error {
            _, err := fmt.Fprintln(cmd.OutOrStdout(), s) // stdout, not INF logs
            return err
        }))
        interp.Verbose = verbose
        return interp.RunFile(args[0])
    },
}
runCmd.Flags().BoolP("verbose", "v", false,
    "dump variable bindings and trace after script end")

3. Demo Flask services — _require returns JSON 400

The demo apps returned Flask's default HTML 500 when a required field was missing. The _require helper normalizes validation to JSON 400:

# demo/services/_common.py (or inline per service)
def _require(*fields):
    """Return a JSON 400 response naming the first missing required field,
    or None when all fields are present. Never raises -> never HTML 500."""
    body = request.get_json(silent=True) or {}
    missing = [f for f in fields
               if f not in body or body[f] is None or body[f] == ""]
    if missing:
        return jsonify({
            "error": "missing required field",
            "field": missing[0],
            "required": list(fields),
        }), 400
    return None

@app.post("/echo")
def echo():
    err = _require("message")
    if err is not None:
        return err
    return jsonify({"echo": request.json["message"]}), 200