cli.go

package main

import (
	"context"
	"fmt"
	"net/http"
	"os"
	"strings"
	"text/tabwriter"
	"time"

	cli "github.com/urfave/cli/v3"
)

func checkAction(_ context.Context, cmd *cli.Command) error {
	page, err := resolveStatusPage(cmd.Args().First(), cmd.Root().String("config"))
	if err != nil {
		return err
	}

	page.Client = &http.Client{}

	cmps, err := page.Components()
	if err != nil {
		return fmt.Errorf("failed to fetch components: %w", err)
	}

	writer := tabwriter.NewWriter(os.Stdout, 4, 4, 1, ' ', 0)
	fTime := cmps.Page.UpdatedAt.Format(time.RFC822)
	fmt.Fprintf(writer, "=== %s Components as of %s === \n", cmps.Page.Name, fTime)
	for _, c := range cmps.Components {
		if c.Group || (c.OnlyShowIfDegraded && c.Status == "operational") {
			continue
		}
		fmt.Fprintf(writer, "%s\t%s\n", c.Name, toIcon(c.Status))
	}

	incs, err := page.Incidents()
	if err != nil {
		return fmt.Errorf("failed to fetch incidents: %w", err)
	}

	if len(incs.Incidents) > 0 {
		fmt.Fprint(writer, "\n=== Incidents ===")
		for _, i := range incs.Incidents {
			fTime := i.UpdatedAt.Format(time.RFC822)
			fmt.Fprintf(writer, "\nName:\t%s\n", i.Name)
			fmt.Fprintf(writer, "Impact:\t%s %s\n", toIcon(i.Impact), i.Impact)
			fmt.Fprintf(writer, "Status:\t%s\n", i.Status)
			fmt.Fprintf(writer, "Details:\t%s\n", i.Updates[0].Body)
			fmt.Fprintf(writer, "Link:\t%s\n", i.ShortLink)
			fmt.Fprintf(writer, "Last Updated:\t%s\n", fTime)
		}
	}
	return writer.Flush()
}

func listAction(_ context.Context, cmd *cli.Command) error {
	cfg := loadConfig(cmd.Root().String("config"))
	if cfg != nil {
		for name, page := range cfg.Pages {
			registry[strings.ToLower(name)] = page
		}
	}
	writer := tabwriter.NewWriter(os.Stdout, 2, 4, 2, ' ', 0)
	for _, name := range knownServices() {
		fmt.Fprintf(writer, "%s\t%s\n", name, registry[name].URL)
	}
	return writer.Flush()
}

func addAction(_ context.Context, cmd *cli.Command) error {
	url := cmd.Args().First()
	if url == "" {
		return fmt.Errorf("url is required: ruok add <url> --alias <name>")
	}
	if !strings.HasPrefix(url, "http://") && !strings.HasPrefix(url, "https://") {
		return fmt.Errorf("url must start with http:// or https://")
	}
	aliases := cmd.StringSlice("alias")
	if len(aliases) == 0 {
		return fmt.Errorf("at least one --alias is required")
	}

	// Validate that the URL points to an actual Statuspage
	sp := StatusPage{URL: url, Client: &http.Client{}}
	if _, err := sp.Components(); err != nil {
		return fmt.Errorf("URL does not appear to be a valid Statuspage: %w", err)
	}

	cfgPath := cmd.Root().String("config")
	cfg := loadConfig(cfgPath)
	if cfg == nil {
		cfg = &Config{}
	}
	if cfg.Pages == nil {
		cfg.Pages = make(map[string]StatusPage)
	}
	for _, alias := range aliases {
		cfg.Pages[strings.ToLower(alias)] = StatusPage{URL: url}
	}
	if err := saveConfig(cfgPath, cfg); err != nil {
		return fmt.Errorf("failed to save config: %w", err)
	}
	fmt.Printf("added %s as %s\n", url, strings.Join(aliases, ", "))
	return nil
}

func buildRootCommand() *cli.Command {
	return &cli.Command{
		Name:    "ruok",
		Usage:   "Check the status of any Statuspage-powered service",
		Version: "0.2.0",
		Action:  checkAction,
		Flags: []cli.Flag{
			&cli.StringFlag{
				Name:    "config",
				Aliases: []string{"c"},
				Usage:   "Path to config file",
			},
		},
		Commands: []*cli.Command{
			{
				Name:    "list",
				Aliases: []string{"ls"},
				Usage:   "List known services",
				Action:  listAction,
			},
			{
				Name:      "add",
				Usage:     "Add a service to the config file",
				ArgsUsage: "<url>",
				Action:    addAction,
				Flags: []cli.Flag{
					&cli.StringSliceFlag{
						Name:    "alias",
						Aliases: []string{"a"},
						Usage:   "Name to register the service under (repeatable)",
					},
				},
			},
		},
	}
}