package cli import ( "context" "errors" "fmt" "sort" "strings" "text/template" "gitea.maximumdirect.net/eric/notarius/internal/core/config" "gitea.maximumdirect.net/eric/notarius/internal/framework/pipeline" "gitea.maximumdirect.net/eric/notarius/internal/preflight" "go.maximumdirect.net/ckconfig" "go.maximumdirect.net/commandkit" "go.maximumdirect.net/configkit" "go.maximumdirect.net/promptkit" ) type pipelineInspectionInput struct { Selection ckconfig.Selection PipelineID string } func configurationSelectionFlags[I any](destination func(*I) *ckconfig.Selection) []commandkit.Flag[I] { return []commandkit.Flag[I]{ commandkit.ValueFlag(commandkit.FlagMeta{Name: "config", Usage: "Select the application configuration.", Completion: commandkit.CompleteFiles()}, (*string)(nil), func(value string) (string, error) { if strings.TrimSpace(value) == "" { return "", fmt.Errorf("--config must not be empty") } return value, nil }, func(input *I, value commandkit.Supplied[string]) { destination(input).Config = value }), commandkit.ValueFlag(commandkit.FlagMeta{Name: "overlay", Usage: "Select a configuration overlay.", Completion: commandkit.CompleteFiles()}, (*string)(nil), func(value string) (string, error) { return value, nil }, func(input *I, value commandkit.Supplied[string]) { destination(input).Overlay = value }), commandkit.RepeatFlag(commandkit.FlagMeta{Name: "set", Usage: "Override POINTER=JSON."}, []configkit.Override(nil), parseConfigurationOverride, func(input *I, value commandkit.Supplied[[]configkit.Override]) { destination(input).Overrides = value.Value }), } } func parseConfigurationOverride(raw string) (configkit.Override, error) { pointer, encoded, ok := strings.Cut(raw, "=") if !ok { return configkit.Override{}, fmt.Errorf("override requires POINTER=JSON") } path, err := configkit.ParsePath(pointer) if err != nil { return configkit.Override{}, err } value, err := commandkit.ParseCLIJSON(encoded) if err != nil { return configkit.Override{}, err } return configkit.Override{Path: path, Value: value, Flag: "--set"}, nil } func pipelineCommands(newState func() *nativeLoaders, catalog func() (pipeline.ModuleCatalog, error), additional ...commandkit.Command) commandkit.Command { command := func(operation, summary string) commandkit.Command { var arguments []commandkit.Argument[pipelineInspectionInput] if operation != "list" { arguments = []commandkit.Argument[pipelineInspectionInput]{commandkit.ValueArgument(commandkit.ArgumentMeta{Name: "pipeline-id", Usage: "Configured pipeline identifier."}, true, func(value string) (string, error) { value = strings.TrimSpace(value) if value == "" { return "", fmt.Errorf("pipeline id must not be empty") } return value, nil }, func(input *pipelineInspectionInput, value commandkit.Supplied[string]) { input.PipelineID = value.Value })} } return commandkit.NewCommand(commandkit.CommandSpec[pipelineInspectionInput]{Name: operation, Summary: summary, Flags: configurationSelectionFlags(func(input *pipelineInspectionInput) *ckconfig.Selection { return &input.Selection }), Arguments: arguments, CheckInput: func(input pipelineInspectionInput) error { return checkConfigSelection(input.Selection) }, Run: func(invocation commandkit.Invocation, input pipelineInspectionInput) commandkit.Outcome { state := newState() result, err := state.application(invocation.Context, input.Selection) if err != nil { return pipelineConfigurationFailure(err) } if operation == "list" { ids := make([]string, 0, len(result.Config.Pipelines)) for id := range result.Config.Pipelines { ids = append(ids, id) } sort.Strings(ids) return reportPipelineInspection(invocation, commandkit.Report{Value: ids}) } loaded, err := config.FromResult(result) if err != nil { return pipelineInvalidConfiguration(err) } modules, err := catalog() if err != nil { return commandkit.Failure(err.Error()).WithCause(err) } effective, err := loaded.RuntimeConfig().Resolve(config.ResolveInput{PipelineID: input.PipelineID, Catalog: modules}) if err != nil { return pipelineInvalidConfiguration(err) } if operation == "show" { return reportPipelineInspection(invocation, commandkit.Report{Value: describePipeline(effective.ResolvedPipeline, modules)}) } var engine *promptkit.Engine if preflight.RequiresEngine(effective.ResolvedPipeline) { engine, err = state.engine(invocation.Context, input.Selection) if err != nil { return pipelineConfigurationFailure(fmt.Errorf("pipeline %q native resources: %w", input.PipelineID, err)) } } if err := preflight.Validate(invocation.Context, effective.ResolvedPipeline, modules, engine); err != nil { return pipelineInvalidConfiguration(err) } return reportPipelineInspection(invocation, commandkit.Report{Value: struct { Pipeline string `json:"pipeline"` Valid bool `json:"valid"` }{input.PipelineID, true}, TextTemplate: pipelineValidationTemplate}) }, }) } children := []commandkit.Command{command("list", "List configured pipeline identifiers."), command("show", "Show a resolved pipeline composition."), command("validate", "Validate known pipeline dependencies offline.")} return commandkit.Group("pipeline", "Inspect, validate, or execute configured pipelines.", append(children, additional...)...) } var pipelineValidationTemplate = template.Must(commandkit.ParseTextTemplate("pipeline-validation", "Pipeline {{printf \"%q\" .Pipeline}} is valid.\n", nil)) func reportPipelineInspection(invocation commandkit.Invocation, report commandkit.Report) commandkit.Outcome { if err := invocation.Reporter().Report(report); err != nil { return commandkit.Failure("Could not report pipeline inspection.").WithCause(err) } return commandkit.Success() } func pipelineConfigurationFailure(err error) commandkit.Outcome { if ckconfig.ClassifyConfigurationError(err) == commandkit.OutcomeUsage { return commandkit.Usage(err.Error()).WithCause(err) } return commandkit.Failure(err.Error()).WithCause(err) } func pipelineInvalidConfiguration(err error) commandkit.Outcome { if errors.Is(err, context.Canceled) || errors.Is(err, context.DeadlineExceeded) { return commandkit.Failure(err.Error()).WithCause(err) } return commandkit.Usage(err.Error()).WithCause(err) }