deployment.go

package cmd

import (
	"bufio"
	"bytes"
	"context"
	"embed"
	"encoding/json"
	"errors"
	"fmt"
	"os"
	"os/signal"
	"strings"
	"syscall"
	"text/template"

	"github.com/charmbracelet/glamour"
	"github.com/massdriver-cloud/mass/docs/helpdocs"
	"github.com/massdriver-cloud/mass/internal/cli"
	"github.com/massdriver-cloud/mass/internal/prettylogs"
	"github.com/massdriver-cloud/massdriver-sdk-go/massdriver"

	"github.com/massdriver-cloud/massdriver-sdk-go/massdriver/platform/deployments"
	"github.com/massdriver-cloud/massdriver-sdk-go/massdriver/platform/types"
	"github.com/spf13/cobra"
)

//go:embed templates/deployment.get.md.tmpl
var deploymentTemplates embed.FS

// NewCmdDeployment returns a cobra command for managing deployments.
func NewCmdDeployment() *cobra.Command {
	deploymentCmd := &cobra.Command{
		Use:     "deployment",
		Aliases: []string{"dep"},
		Short:   "Manage deployments",
		Long:    helpdocs.MustRender("deployment"),
	}

	deploymentGetCmd := &cobra.Command{
		Use:     "get <deployment-id>",
		Short:   "Get a deployment by ID",
		Example: `mass deployment get 12345678-1234-1234-1234-123456789012`,
		Long:    helpdocs.MustRender("deployment/get"),
		Args:    cobra.ExactArgs(1),
		RunE:    runDeploymentGet,
	}
	deploymentGetCmd.Flags().StringP("output", "o", "text", "Output format (text or json)")

	deploymentListCmd := &cobra.Command{
		Use:     "list <instance-id>",
		Aliases: []string{"ls"},
		Short:   "List deployments for an instance (most recent first)",
		Example: `mass deployment list ecomm-prod-db --limit 25`,
		Long:    helpdocs.MustRender("deployment/list"),
		Args:    cobra.ExactArgs(1),
		RunE:    runDeploymentList,
	}
	deploymentListCmd.Flags().IntP("limit", "n", 10, "Maximum number of deployments to return (max 100)")
	deploymentListCmd.Flags().StringP("output", "o", "table", "Output format (table, json)")
	deploymentListCmd.Flags().String("status", "", "Filter by status (pending, approved, running, completed, failed, aborted, rejected, proposed)")
	deploymentListCmd.Flags().String("action", "", "Filter by action (provision, decommission, plan)")
	deploymentListCmd.Flags().String("repo", "", "Filter by OCI repo name")
	deploymentListCmd.Flags().String("bundle", "", "Filter by bundle version (name@version) or release channel (name@latest)")

	deploymentLogsCmd := &cobra.Command{
		Use:     "logs <deployment-id>",
		Short:   "Stream the log output from a deployment",
		Example: `mass deployment logs 12345678-1234-1234-1234-123456789012`,
		Long:    helpdocs.MustRender("deployment/logs"),
		Args:    cobra.ExactArgs(1),
		RunE:    runDeploymentLogs,
	}

	deploymentAbortCmd := &cobra.Command{
		Use:     "abort <deployment-id>",
		Short:   "Abort a pending, approved, or running deployment",
		Example: `mass deployment abort 12345678-1234-1234-1234-123456789012 --force`,
		Long:    helpdocs.MustRender("deployment/abort"),
		Args:    cobra.ExactArgs(1),
		RunE:    runDeploymentAbort,
	}
	deploymentAbortCmd.Flags().BoolP("force", "f", false, "Skip confirmation prompt")

	deploymentCmd.AddCommand(deploymentGetCmd)
	deploymentCmd.AddCommand(deploymentListCmd)
	deploymentCmd.AddCommand(deploymentLogsCmd)
	deploymentCmd.AddCommand(deploymentAbortCmd)

	return deploymentCmd
}

func runDeploymentGet(cmd *cobra.Command, args []string) error {
	ctx := context.Background()
	deploymentID := args[0]

	outputFormat, err := cmd.Flags().GetString("output")
	if err != nil {
		return err
	}
	cmd.SilenceUsage = true

	mdClient, err := massdriver.NewClient()
	if err != nil {
		return fmt.Errorf("error initializing massdriver client: %w", err)
	}

	deployment, err := mdClient.Deployments.Get(ctx, deploymentID)
	if err != nil {
		return err
	}

	switch outputFormat {
	case "json":
		jsonBytes, marshalErr := json.MarshalIndent(deployment, "", "  ")
		if marshalErr != nil {
			return fmt.Errorf("failed to marshal deployment to JSON: %w", marshalErr)
		}
		fmt.Println(string(jsonBytes))
	case "text":
		return renderDeployment(deployment)
	default:
		return fmt.Errorf("unsupported output format: %s", outputFormat)
	}

	return nil
}

func runDeploymentList(cmd *cobra.Command, args []string) error {
	ctx := context.Background()
	instanceID := args[0]

	limit, err := cmd.Flags().GetInt("limit")
	if err != nil {
		return err
	}
	status, _ := cmd.Flags().GetString("status")
	action, _ := cmd.Flags().GetString("action")
	repo, _ := cmd.Flags().GetString("repo")
	bundle, _ := cmd.Flags().GetString("bundle")
	output, _ := cmd.Flags().GetString("output")
	cmd.SilenceUsage = true

	mdClient, err := massdriver.NewClient()
	if err != nil {
		return fmt.Errorf("error initializing massdriver client: %w", err)
	}

	// SDK's Iter auto-paginates without a total cap; we want a total cap, so
	// drive Iter and stop after `limit` items.
	listInput := deployments.ListInput{
		InstanceID:  instanceID,
		OciRepoName: repo,
		BundleID:    bundle,
		SortBy:      deployments.SortByCreatedAt,
		SortOrder:   deployments.SortDesc,
	}
	if status != "" {
		listInput.Status = deployments.Status(strings.ToUpper(status))
	}
	if action != "" {
		listInput.Action = deployments.Action(strings.ToUpper(action))
	}

	deps := make([]deployments.Deployment, 0, limit)
	for d, iterErr := range mdClient.Deployments.Iter(ctx, listInput) {
		if iterErr != nil {
			return iterErr
		}
		if limit > 0 && len(deps) >= limit {
			break
		}
		deps = append(deps, d)
	}

	switch output {
	case "json":
		jsonBytes, marshalErr := json.MarshalIndent(deps, "", "  ")
		if marshalErr != nil {
			return fmt.Errorf("failed to marshal deployments to JSON: %w", marshalErr)
		}
		fmt.Println(string(jsonBytes))
		return nil
	case "table":
		tbl := cli.NewTable("ID", "Action", "Status", "Version", "Created At", "By", "Message")
		for _, d := range deps {
			tbl.AddRow(d.ID, d.Action, d.Status, d.Version, d.CreatedAt, d.DeployedBy, cli.TruncateString(d.Message, 40))
		}
		tbl.Print()
		return nil
	default:
		return fmt.Errorf("unsupported output format: %s", output)
	}
}

func runDeploymentLogs(cmd *cobra.Command, args []string) error {
	deploymentID := args[0]
	cmd.SilenceUsage = true

	ctx, cancel := signalContext(context.Background())
	defer cancel()

	mdClient, err := massdriver.NewClient()
	if err != nil {
		return fmt.Errorf("error initializing massdriver client: %w", err)
	}

	// TailLogs collapses backfill + terminal-check + live streaming into one call.
	tailErr := mdClient.Deployments.TailLogs(ctx, deploymentID, os.Stdout)
	if errors.Is(tailErr, deployments.ErrStreamingRequiresPAT) {
		// Fall back to a one-shot static-log dump so the user still gets the
		// available history. Streaming would require a personal access token.
		fmt.Fprintln(os.Stderr, "warning: log streaming requires a personal access token (mds_*/md_*); showing static logs instead")
		backfill, err := mdClient.Deployments.GetLogs(ctx, deploymentID)
		if err != nil {
			return fmt.Errorf("error getting deployment logs: %w", err)
		}
		fmt.Fprint(os.Stdout, backfill)
		return nil
	}
	if tailErr != nil && !errors.Is(tailErr, context.Canceled) {
		return tailErr
	}
	return nil
}

// signalContext returns a derived context that cancels on SIGINT/SIGTERM, so
// Ctrl-C cleanly tears down the WebSocket and exits.
func signalContext(parent context.Context) (context.Context, context.CancelFunc) {
	return signal.NotifyContext(parent, syscall.SIGINT, syscall.SIGTERM)
}

func runDeploymentAbort(cmd *cobra.Command, args []string) error {
	ctx := context.Background()
	deploymentID := args[0]

	force, err := cmd.Flags().GetBool("force")
	if err != nil {
		return err
	}
	cmd.SilenceUsage = true

	if !force {
		fmt.Printf("%s: This will abort deployment %s. A running deployment aborted mid-flight leaves any partial infrastructure changes in place, and does not halt execution of the deployment if it is already running.\n", prettylogs.Orange("WARNING"), deploymentID)
		fmt.Printf("Type '%s' to confirm abort: ", deploymentID)
		reader := bufio.NewReader(os.Stdin)
		answer, _ := reader.ReadString('\n')
		if strings.TrimSpace(answer) != deploymentID {
			fmt.Println("Abort cancelled.")
			return nil
		}
	}

	mdClient, err := massdriver.NewClient()
	if err != nil {
		return fmt.Errorf("error initializing massdriver client: %w", err)
	}

	aborted, err := mdClient.Deployments.Abort(ctx, deploymentID)
	if err != nil {
		return err
	}

	fmt.Printf("✅ Deployment `%s` aborted (status: %s)\n", aborted.ID, aborted.Status)
	return nil
}

//nolint:dupl // parallel template-render shape with renderInstance; consolidating would couple unrelated commands
func renderDeployment(deployment *types.Deployment) error {
	tmplBytes, err := deploymentTemplates.ReadFile("templates/deployment.get.md.tmpl")
	if err != nil {
		return fmt.Errorf("failed to read template: %w", err)
	}

	tmpl, err := template.New("deployment").Funcs(cli.MarkdownTemplateFuncs).Parse(string(tmplBytes))
	if err != nil {
		return fmt.Errorf("failed to parse template: %w", err)
	}

	paramsJSON := "{}"
	if deployment.Params != nil {
		if b, marshalErr := json.MarshalIndent(deployment.Params, "", "  "); marshalErr == nil {
			paramsJSON = string(b)
		}
	}

	data := struct {
		*types.Deployment
		ParamsJSON string
	}{Deployment: deployment, ParamsJSON: paramsJSON}

	var buf bytes.Buffer
	if renderErr := tmpl.Execute(&buf, data); renderErr != nil {
		return fmt.Errorf("failed to execute template: %w", renderErr)
	}

	r, err := glamour.NewTermRenderer(glamour.WithAutoStyle())
	if err != nil {
		return err
	}

	out, err := r.Render(buf.String())
	if err != nil {
		return err
	}

	fmt.Print(out)
	return nil
}