banger/internal/cli/commands_kernel.go

package cli

import (
	"errors"
	"fmt"
	"path/filepath"
	"strings"

	"banger/internal/api"
	"banger/internal/rpc"

	"github.com/spf13/cobra"
)

func newKernelCommand() *cobra.Command {
	cmd := &cobra.Command{
		Use:   "kernel",
		Short: "Manage the local kernel catalog",
		RunE:  helpNoArgs,
	}
	cmd.AddCommand(
		newKernelListCommand(),
		newKernelShowCommand(),
		newKernelRmCommand(),
		newKernelImportCommand(),
		newKernelPullCommand(),
	)
	return cmd
}

func newKernelPullCommand() *cobra.Command {
	var force bool
	cmd := &cobra.Command{
		Use:   "pull <name>",
		Short: "Download a cataloged kernel bundle",
		Args:  exactArgsUsage(1, "usage: banger kernel pull <name> [--force]"),
		RunE: func(cmd *cobra.Command, args []string) error {
			layout, _, err := ensureDaemon(cmd.Context())
			if err != nil {
				return err
			}
			var result api.KernelShowResult
			err = withHeartbeat(cmd.ErrOrStderr(), "kernel pull", func() error {
				var callErr error
				result, callErr = rpc.Call[api.KernelShowResult](cmd.Context(), layout.SocketPath, "kernel.pull", api.KernelPullParams{Name: args[0], Force: force})
				return callErr
			})
			if err != nil {
				return err
			}
			return printJSON(cmd.OutOrStdout(), result.Entry)
		},
	}
	cmd.Flags().BoolVar(&force, "force", false, "re-pull even if already present")
	return cmd
}

func newKernelImportCommand() *cobra.Command {
	var params api.KernelImportParams
	cmd := &cobra.Command{
		Use:   "import <name>",
		Short: "Import a kernel bundle produced by scripts/make-*-kernel.sh",
		Long:  "Copy the kernel, optional initrd, and optional modules directory from <from> into the local kernel catalog keyed by <name>. <from> is usually build/manual/void-kernel or build/manual/alpine-kernel.",
		Args:  exactArgsUsage(1, "usage: banger kernel import <name> --from <dir>"),
		RunE: func(cmd *cobra.Command, args []string) error {
			params.Name = args[0]
			if strings.TrimSpace(params.FromDir) == "" {
				return errors.New("--from <dir> is required")
			}
			abs, err := filepath.Abs(params.FromDir)
			if err != nil {
				return err
			}
			params.FromDir = abs
			layout, _, err := ensureDaemon(cmd.Context())
			if err != nil {
				return err
			}
			result, err := rpc.Call[api.KernelShowResult](cmd.Context(), layout.SocketPath, "kernel.import", params)
			if err != nil {
				return err
			}
			return printJSON(cmd.OutOrStdout(), result.Entry)
		},
	}
	cmd.Flags().StringVar(&params.FromDir, "from", "", "directory produced by make-*-kernel.sh (e.g. build/manual/void-kernel)")
	cmd.Flags().StringVar(&params.Distro, "distro", "", "distribution label stored in the manifest (e.g. void, alpine)")
	cmd.Flags().StringVar(&params.Arch, "arch", "", "architecture label stored in the manifest (e.g. x86_64)")
	return cmd
}

func newKernelListCommand() *cobra.Command {
	var available bool
	cmd := &cobra.Command{
		Use:     "list",
		Aliases: []string{"ls"},
		Short:   "List kernels (local by default, or --available for the catalog)",
		Args:    noArgsUsage("usage: banger kernel list [--available]"),
		RunE: func(cmd *cobra.Command, args []string) error {
			layout, _, err := ensureDaemon(cmd.Context())
			if err != nil {
				return err
			}
			if available {
				result, err := rpc.Call[api.KernelCatalogResult](cmd.Context(), layout.SocketPath, "kernel.catalog", api.Empty{})
				if err != nil {
					return err
				}
				return printKernelCatalogTable(cmd.OutOrStdout(), result.Entries)
			}
			result, err := rpc.Call[api.KernelListResult](cmd.Context(), layout.SocketPath, "kernel.list", api.Empty{})
			if err != nil {
				return err
			}
			return printKernelListTable(cmd.OutOrStdout(), result.Entries)
		},
	}
	cmd.Flags().BoolVar(&available, "available", false, "show the built-in catalog (with pulled/available status) instead of local entries")
	return cmd
}

func newKernelShowCommand() *cobra.Command {
	return &cobra.Command{
		Use:               "show <name>",
		Short:             "Show kernel catalog entry details",
		Args:              exactArgsUsage(1, "usage: banger kernel show <name>"),
		ValidArgsFunction: completeKernelNameOnlyAtPos0,
		RunE: func(cmd *cobra.Command, args []string) error {
			layout, _, err := ensureDaemon(cmd.Context())
			if err != nil {
				return err
			}
			result, err := rpc.Call[api.KernelShowResult](cmd.Context(), layout.SocketPath, "kernel.show", api.KernelRefParams{Name: args[0]})
			if err != nil {
				return err
			}
			return printJSON(cmd.OutOrStdout(), result.Entry)
		},
	}
}

func newKernelRmCommand() *cobra.Command {
	return &cobra.Command{
		Use:               "rm <name>",
		Aliases:           []string{"remove", "delete"},
		Short:             "Remove a kernel catalog entry",
		Args:              exactArgsUsage(1, "usage: banger kernel rm <name>"),
		ValidArgsFunction: completeKernelNameOnlyAtPos0,
		RunE: func(cmd *cobra.Command, args []string) error {
			layout, _, err := ensureDaemon(cmd.Context())
			if err != nil {
				return err
			}
			if _, err := rpc.Call[api.Empty](cmd.Context(), layout.SocketPath, "kernel.delete", api.KernelRefParams{Name: args[0]}); err != nil {
				return err
			}
			_, err = fmt.Fprintf(cmd.OutOrStdout(), "removed %s\n", args[0])
			return err
		},
	}
}