Switch to cobra for command-line

Author: bigkevmcd

README.md

@@ -16,9 +16,9 @@ go install github.com/bigkevmcd/githubstatus/cmd/githubstatus@latest
 ```
 
 ```sh
-githubstatus -overall major \
-    -component "Actions=partial_outage" \
-    -component "Git Operations=degraded_performance"
+githubstatus --overall major \
+	--component "Actions=partial_outage" \
+	--component "Git Operations=degraded_performance"
 ```
 
 The tool prints the current status and any violations, and sets its exit code
@@ -33,18 +33,18 @@ from the result:
 
 | Flag                   | Default | Description                                                          |
 |------------------------|---------|----------------------------------------------------------------------|
-| `-overall`             | `major` | Lowest overall indicator that counts as unhealthy; `""` disables it   |
-| `-component Name=status` |       | Threshold for one component; repeat the flag for more. Without any, the tool fetches only the small `status.json` |
-| `-fail-on-maintenance` | `false` | Treat planned maintenance as unhealthy                               |
-| `-fail-on-missing`     | `false` | Exit 1 if a `-component` name doesn't exist                          |
-| `-base-url`            | githubstatus.com | Statuspage API base URL                                     |
-| `-timeout`             | `10s`   | Timeout for fetching the status                                      |
+| `--overall`             | `major` | Lowest overall indicator that counts as unhealthy; `""` disables it   |
+| `--component Name=status` |       | Threshold for one component; repeat the flag for more. Without any, the tool fetches only the small `status.json` |
+| `--fail-on-maintenance` | `false` | Treat planned maintenance as unhealthy                               |
+| `--fail-on-missing`     | `false` | Exit 1 if a `--component` name doesn't exist                         |
+| `--base-url`            | githubstatus.com | Statuspage API base URL                                     |
+| `--timeout`             | `10s`   | Timeout for fetching the status                                      |
 | `-q`                   | `false` | Print nothing; only set the exit code                                |
 
 For example, to skip a deploy step while GitHub Actions is having problems:
 
 ```sh
-githubstatus -q -component "Actions=partial_outage" && ./deploy.sh
+githubstatus -q --component "Actions=partial_outage" && ./deploy.sh
 ```
 
 ## MCP server
@@ -73,21 +73,21 @@ Other MCP clients use a config like this:
 }
 ```
 
-To run it as a shared server instead, use `-http`. This serves the MCP
+To run it as a shared server instead, use `--http`. This serves the MCP
 streamable HTTP transport at `/mcp`:
 
 ```sh
-githubstatus-mcp -http localhost:8080   # endpoint: http://localhost:8080/mcp
+githubstatus-mcp --http localhost:8080   # endpoint: http://localhost:8080/mcp
 ```
 
 The HTTP server rejects cross-origin browser requests and DNS-rebinding
 attempts, but it has no authentication. Only expose it on a trusted network.
 
 | Flag         | Default          | Description                                              |
 |--------------|------------------|----------------------------------------------------------|
-| `-http`      |                  | Serve over HTTP on this address instead of stdio         |
-| `-cache-ttl` | `30s`            | How long to reuse API responses; `0` disables caching    |
-| `-base-url`  | githubstatus.com | Statuspage API base URL                                  |
+| `--http`      |                  | Serve over HTTP on this address instead of stdio         |
+| `--cache-ttl` | `30s`            | How long to reuse API responses; `0` disables caching    |
+| `--base-url`  | githubstatus.com | Statuspage API base URL                                  |
 
 ### Tools
 

client.go

@@ -127,7 +127,7 @@ func (c *Client) get(ctx context.Context, path string, v any) error {
 	if err != nil {
 		return fmt.Errorf("githubstatus: %w", err)
 	}
-	defer resp.Body.Close()
+	defer func() { _ = resp.Body.Close() }()
 
 	if resp.StatusCode != http.StatusOK {
 		body, _ := io.ReadAll(io.LimitReader(resp.Body, maxErrorBodyBytes))

cmd/githubstatus-mcp/main.go

@@ -2,10 +2,10 @@
 // exposes GitHub's status from githubstatus.com.
 //
 // By default it communicates over stdio, so it can be launched directly by
-// an MCP client. With -http it instead serves the MCP streamable HTTP
+// an MCP client. With --http it instead serves the MCP streamable HTTP
 // transport at /mcp on the given address:
 //
-//	githubstatus-mcp -http localhost:8080
+//	githubstatus-mcp --http localhost:8080
 //
 // The HTTP server has no authentication; only expose it on a trusted
 // network.
@@ -14,7 +14,6 @@ package main
 import (
 	"context"
 	"errors"
-	"flag"
 	"fmt"
 	"io"
 	"log"
@@ -27,6 +26,7 @@ import (
 	"time"
 
 	"github.com/modelcontextprotocol/go-sdk/mcp"
+	"github.com/spf13/cobra"
 
 	"github.com/bigkevmcd/githubstatus"
 	"github.com/bigkevmcd/githubstatus/mcpserver"
@@ -41,10 +41,6 @@ func main() {
 
 	stop()
 
-	if errors.Is(err, flag.ErrHelp) {
-		return
-	}
-
 	if err != nil {
 		os.Exit(1)
 	}
@@ -56,44 +52,55 @@ func main() {
 func run(ctx context.Context, args []string, stderr io.Writer) error {
 	logger := log.New(stderr, "githubstatus-mcp: ", 0)
 
-	fs := flag.NewFlagSet("githubstatus-mcp", flag.ContinueOnError)
-	fs.SetOutput(stderr)
-	baseURL := fs.String("base-url", githubstatus.DefaultBaseURL, "Statuspage API base URL")
-	httpAddr := fs.String("http", "", `serve MCP over streamable HTTP at `+httpPath+` on this address (e.g. "localhost:8080") instead of stdio`)
-	cacheTTL := fs.Duration("cache-ttl", mcpserver.DefaultCacheTTL, "how long to reuse API responses; negative disables caching")
-
-	fs.Usage = func() {
-		fmt.Fprintf(stderr, "Usage: githubstatus-mcp [flags]\n\nRuns an MCP server exposing GitHub's status, over stdio by default.\n\nFlags:\n")
-		fs.PrintDefaults()
-	}
-	if err := fs.Parse(args); err != nil {
-		return err
-	}
-
-	if fs.NArg() > 0 {
-		err := fmt.Errorf("unexpected arguments: %v", fs.Args())
-		logger.Print(err)
-
-		return err
-	}
-
-	if *cacheTTL == 0 {
-		*cacheTTL = -1 // the flag's 0 means "off"; Options' 0 means "default"
+	baseURL := githubstatus.DefaultBaseURL
+
+	var httpAddr string
+
+	cacheTTL := mcpserver.DefaultCacheTTL
+	cmd := &cobra.Command{
+		Use:           "githubstatus-mcp",
+		Short:         "Expose GitHub status over MCP",
+		SilenceUsage:  true,
+		SilenceErrors: true,
+		Args: func(_ *cobra.Command, args []string) error {
+			if len(args) > 0 {
+				return fmt.Errorf("unexpected arguments: %v", args)
+			}
+
+			return nil
+		},
+		RunE: func(_ *cobra.Command, _ []string) error {
+			if cacheTTL == 0 {
+				cacheTTL = -1 // the flag's 0 means "off"; Options' 0 means "default"
+			}
+
+			server := mcpserver.New(&githubstatus.Client{BaseURL: baseURL}, &mcpserver.Options{
+				Version:  version(),
+				CacheTTL: cacheTTL,
+			})
+
+			var err error
+			if httpAddr != "" {
+				err = serveHTTP(ctx, server, httpAddr, logger)
+			} else {
+				err = server.Run(ctx, &mcp.StdioTransport{})
+			}
+
+			if err != nil && ctx.Err() == nil {
+				return err
+			}
+
+			return nil
+		},
 	}
-
-	server := mcpserver.New(&githubstatus.Client{BaseURL: *baseURL}, &mcpserver.Options{
-		Version:  version(),
-		CacheTTL: *cacheTTL,
-	})
-
-	var err error
-	if *httpAddr != "" {
-		err = serveHTTP(ctx, server, *httpAddr, logger)
-	} else {
-		err = server.Run(ctx, &mcp.StdioTransport{})
-	}
-
-	if err != nil && ctx.Err() == nil {
+	cmd.Flags().StringVar(&baseURL, "base-url", baseURL, "Statuspage API base URL")
+	cmd.Flags().StringVar(&httpAddr, "http", "", `serve MCP over streamable HTTP at `+httpPath+` on this address (e.g. "localhost:8080") instead of stdio`)
+	cmd.Flags().DurationVar(&cacheTTL, "cache-ttl", cacheTTL, "how long to reuse API responses; negative disables caching")
+	cmd.SetArgs(append([]string{}, args...))
+	cmd.SetOut(stderr)
+	cmd.SetErr(stderr)
+
+	if err := cmd.ExecuteContext(ctx); err != nil {
 		logger.Print(err)
 		return err
 	}

cmd/githubstatus-mcp/main_test.go

@@ -4,8 +4,6 @@ import (
 	"bufio"
 	"bytes"
 	"context"
-	"errors"
-	"flag"
 	"io"
 	"net/http"
 	"net/http/httptest"
@@ -27,10 +25,12 @@ const runMainEnv = "GITHUBSTATUS_MCP_TEST_RUN_MAIN"
 func TestMain(m *testing.M) {
 	if os.Getenv(runMainEnv) == "1" {
 		main()
+		// The test binary is acting as the command process in this branch.
+		//revive:disable-next-line:redundant-test-main-exit
 		os.Exit(0)
 	}
 
-	os.Exit(m.Run())
+	m.Run()
 }
 
 // newStatusAPI serves the summary fixture and returns its base URL.
@@ -89,15 +89,21 @@ func checkSession(t *testing.T, cs *mcp.ClientSession) {
 	}
 
 	out, ok := res.StructuredContent.(map[string]any)
-	if !ok || out["healthy"] != false || out["description"] != "Minor Service Outage" {
+	if !ok {
+		t.Errorf("check_github_health = %#v", res.StructuredContent)
+		return
+	}
+
+	healthy, healthyOK := out["healthy"].(bool)
+	if !healthyOK || healthy || out["description"] != "Minor Service Outage" {
 		t.Errorf("check_github_health = %#v", res.StructuredContent)
 	}
 }
 
 func TestStdio(t *testing.T) {
 	baseURL := newStatusAPI(t)
 
-	cmd := exec.Command(os.Args[0], "-base-url", baseURL)
+	cmd := exec.Command(os.Args[0], "--base-url", baseURL)
 
 	cmd.Env = append(os.Environ(), runMainEnv+"=1")
 
@@ -136,7 +142,7 @@ func TestHTTP(t *testing.T) {
 
 	done := make(chan error, 1)
 	go func() {
-		done <- run(ctx, []string{"-http", "127.0.0.1:0", "-base-url", baseURL}, pw)
+		done <- run(ctx, []string{"--http", "127.0.0.1:0", "--base-url", baseURL}, pw)
 
 		_ = pw.Close()
 	}()
@@ -205,25 +211,25 @@ func TestRunErrors(t *testing.T) {
 	tests := []struct {
 		name       string
 		args       []string
-		wantErr    error
+		wantError  bool
 		wantStderr string
 	}{
-		{"help", []string{"-h"}, flag.ErrHelp, "Usage: githubstatus-mcp"},
-		{"unknown flag", []string{"-bogus"}, nil, "flag provided but not defined: -bogus"},
-		{"unexpected argument", []string{"extra"}, nil, "unexpected arguments: [extra]"},
-		{"bad listen address", []string{"-http", "256.0.0.1:bad"}, nil, "githubstatus-mcp: listen tcp"},
+		{"help", []string{"--help"}, false, "Usage:\n  githubstatus-mcp [flags]"},
+		{"unknown flag", []string{"--bogus"}, true, "unknown flag: --bogus"},
+		{"unexpected argument", []string{"extra"}, true, "unexpected arguments: [extra]"},
+		{"bad listen address", []string{"--http", "256.0.0.1:bad"}, true, "githubstatus-mcp: listen tcp"},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			var stderr bytes.Buffer
 
 			err := run(context.Background(), tt.args, &stderr)
-			if err == nil {
+			if err == nil && tt.wantError {
 				t.Fatal("expected an error")
 			}
 
-			if tt.wantErr != nil && !errors.Is(err, tt.wantErr) {
-				t.Errorf("err = %v, want %v", err, tt.wantErr)
+			if err != nil && !tt.wantError {
+				t.Fatalf("err = %v, want nil", err)
 			}
 
 			if !strings.Contains(stderr.String(), tt.wantStderr) {