Skip to content

Modern Docker Management, Designed for Everyone

17.9 KB
Raw Blame
package repos

import (
	"fmt"
	"net/http"
	"net/url"
	"os"
	"strconv"
	"strings"

	"github.com/getarcaneapp/arcane/types/v2/base"
	"github.com/getarcaneapp/arcane/types/v2/gitops"
	"github.com/spf13/cobra"
	"go.getarcane.app/kit/pkg"

	"github.com/getarcaneapp/arcane/cli/v2/internal/client"
	"github.com/getarcaneapp/arcane/cli/v2/internal/cmdutil"
	"github.com/getarcaneapp/arcane/cli/v2/internal/output"
	"github.com/getarcaneapp/arcane/cli/v2/internal/types"
)

// Command is the parent command for git repository operations.
func Command() *cobra.Command {
	cmd := &cobra.Command{
		Use:     "repos",
		Aliases: []string{"repo", "git-repositories", "git-repos"},
		Short:   "Manage git repositories",
	}
	cmd.AddCommand(newListCmd())
	cmd.AddCommand(newCreateCmd())
	cmd.AddCommand(newGetCmd())
	cmd.AddCommand(newUpdateCmd())
	cmd.AddCommand(newDeleteCmd())
	cmd.AddCommand(newTestCmd())
	cmd.AddCommand(newBranchesCmd())
	cmd.AddCommand(newFilesCmd())
	return cmd
}

func newListCmd() *cobra.Command {
	var opts struct {
		limit int
		start int
		all   bool
	}
	cmd := &cobra.Command{
		Use:          "list",
		Aliases:      []string{"ls"},
		Short:        "List git repositories",
		Args:         cobra.NoArgs,
		SilenceUsage: true,
		RunE: func(cmd *cobra.Command, args []string) error {
			c, err := client.NewFromConfig()
			if err != nil {
				return err
			}

			return cmdutil.RunList(cmd, c, cmdutil.ListSpec[gitops.GitRepository]{
				Resource: "repositories",
				Endpoint: types.GitRepositories(),
				Params:   cmdutil.ListParams{Resource: "repos", Limit: opts.limit, FallbackDefault: 20, Start: opts.start, All: opts.all},
				Headers:  []string{"ID", "NAME", "URL", "AUTH TYPE", "ENABLED", "CREATED"},
				Row: func(repo gitops.GitRepository) []string {
					return []string{
						repo.ID,
						repo.Name,
						repo.URL,
						repo.AuthType,
						strconv.FormatBool(repo.Enabled),
						repo.CreatedAt.Format("2006-01-02 15:04:05"),
					}
				},
			})
		},
	}
	cmd.Flags().IntVarP(&opts.limit, "limit", "n", 20, "Number of repositories to show")
	cmd.Flags().IntVar(&opts.start, "start", 0, cmdutil.StartFlagUsage)
	cmd.Flags().BoolVarP(&opts.all, "all", "a", false, cmdutil.AllFlagUsage)
	return cmd
}

func newCreateCmd() *cobra.Command {
	var opts struct {
		name             string
		url              string
		authType         string
		token            string
		username         string
		sshKey           string
		sshHostKeyVerify string
		authorName       string
		authorEmail      string
		signingKey       string
		signingKeyPass   string
		description      string
		enabled          bool
	}
	cmd := &cobra.Command{
		Use:          "create",
		Short:        "Create a git repository",
		Args:         cobra.NoArgs,
		SilenceUsage: true,
		RunE: func(cmd *cobra.Command, args []string) error {
			c, err := client.NewFromConfig()
			if err != nil {
				return err
			}

			var sshKey string
			if cmd.Flags().Changed("ssh-key") {
				sshKeyData, readFileErr := os.ReadFile(opts.sshKey)
				if readFileErr != nil {
					return fmt.Errorf("failed to read SSH key file: %w", readFileErr)
				}
				sshKey = string(sshKeyData)
			}
			var signingKey string
			if cmd.Flags().Changed("signing-key") {
				signingKeyData, readSigningKeyErr := os.ReadFile(opts.signingKey)
				if readSigningKeyErr != nil {
					return fmt.Errorf("failed to read signing key file: %w", readSigningKeyErr)
				}
				signingKey = string(signingKeyData)
			}

			req := gitops.CreateRepositoryRequest{
				Name:                   opts.name,
				URL:                    opts.url,
				AuthType:               opts.authType,
				Token:                  opts.token,
				Username:               opts.username,
				SSHHostKeyVerification: opts.sshHostKeyVerify,
				CommitAuthorName:       opts.authorName,
				CommitAuthorEmail:      opts.authorEmail,
				SigningKeyPassphrase:   opts.signingKeyPass,
				Description:            kit.Ternary(cmd.Flags().Changed("description"), &opts.description, nil),
				Enabled:                kit.Ternary(cmd.Flags().Changed("enabled"), &opts.enabled, nil),
				SSHKey:                 sshKey,
				SigningKey:             signingKey,
			}

			return cmdutil.Run(cmd, c, cmdutil.Spec[gitops.GitRepository]{
				Method:         http.MethodPost,
				Path:           types.GitRepositories(),
				Body:           req,
				FailureMessage: "failed to create repository",
				Render: func(data gitops.GitRepository) error {
					output.Success("Repository created successfully")
					output.KeyValue("ID", data.ID)
					output.KeyValue("Name", data.Name)
					output.KeyValue("URL", data.URL)
					output.KeyValue("Auth Type", data.AuthType)
					output.KeyValue("Enabled", data.Enabled)
					return nil
				},
			})
		},
	}
	cmd.Flags().StringVar(&opts.name, "name", "", "Repository name")
	cmd.Flags().StringVar(&opts.url, "url", "", "Repository URL")
	cmdutil.EnumVarP(cmd, cmd.Flags(), &opts.authType, "auth-type", "", "", "Authentication type", "none", "http", "ssh")
	cmd.Flags().StringVar(&opts.token, "token", "", "Token for HTTP authentication")
	cmd.Flags().StringVar(&opts.username, "username", "", "Username for HTTP authentication")
	cmd.Flags().StringVar(&opts.sshKey, "ssh-key", "", "Path to SSH key file")
	cmdutil.EnumVarP(cmd, cmd.Flags(), &opts.sshHostKeyVerify, "ssh-host-key-verification", "", "", "SSH host key verification", "strict", "accept_new", "skip")
	cmd.Flags().StringVar(&opts.authorName, "author-name", "", "Author name for commits Arcane pushes")
	cmd.Flags().StringVar(&opts.authorEmail, "author-email", "", "Author email for commits Arcane pushes")
	cmd.Flags().StringVar(&opts.signingKey, "signing-key", "", "Path to an armored OpenPGP private key used to sign commits")
	cmd.Flags().StringVar(&opts.signingKeyPass, "signing-key-passphrase", "", "Passphrase for the signing key")
	cmd.Flags().StringVar(&opts.description, "description", "", "Repository description")
	cmd.Flags().BoolVar(&opts.enabled, "enabled", true, "Enable the repository")
	_ = cmd.MarkFlagRequired("name")
	_ = cmd.MarkFlagRequired("url")
	_ = cmd.MarkFlagRequired("auth-type")
	return cmd
}

func newGetCmd() *cobra.Command {
	return &cobra.Command{
		Use:          "get <repository>",
		Short:        "Get git repository details",
		Args:         cobra.ExactArgs(1),
		SilenceUsage: true,
		RunE: func(cmd *cobra.Command, args []string) error {
			c, err := client.NewFromConfig()
			if err != nil {
				return err
			}

			resolved, _, err := repoRef.Resolve(cmd.Context(), c, args[0], cmdutil.AllowPrompt(cmd))
			if err != nil {
				return err
			}

			if cmdutil.JSONOutputEnabled(cmd) {
				return cmdutil.PrintJSON(resolved)
			}

			output.Header("Repository Details")
			output.KeyValue("ID", resolved.ID)
			output.KeyValue("Name", resolved.Name)
			output.KeyValue("URL", resolved.URL)
			output.KeyValue("Auth Type", resolved.AuthType)
			if resolved.Username != "" {
				output.KeyValue("Username", resolved.Username)
			}
			if resolved.SSHHostKeyVerification != "" {
				output.KeyValue("SSH Host Key Verification", resolved.SSHHostKeyVerification)
			}
			if resolved.CommitAuthorName != "" || resolved.CommitAuthorEmail != "" {
				output.KeyValue("Commit Author", strings.TrimSpace(resolved.CommitAuthorName+" <"+resolved.CommitAuthorEmail+">"))
			}
			output.KeyValue("Signing Key", resolved.HasSigningKey)
			if resolved.Description != nil {
				output.KeyValue("Description", *resolved.Description)
			}
			output.KeyValue("Enabled", resolved.Enabled)
			output.KeyValue("Created", resolved.CreatedAt.Format("2006-01-02 15:04:05"))
			output.KeyValue("Updated", resolved.UpdatedAt.Format("2006-01-02 15:04:05"))
			return nil
		},
	}
}

func newUpdateCmd() *cobra.Command {
	var opts struct {
		name             string
		url              string
		authType         string
		token            string
		username         string
		sshKey           string
		sshHostKeyVerify string
		authorName       string
		authorEmail      string
		signingKey       string
		signingKeyPass   string
		description      string
		enabled          bool
	}
	cmd := &cobra.Command{
		Use:          "update <repository>",
		Short:        "Update a git repository",
		Args:         cobra.ExactArgs(1),
		SilenceUsage: true,
		RunE: func(cmd *cobra.Command, args []string) error {
			c, err := client.NewFromConfig()
			if err != nil {
				return err
			}

			resolved, _, err := repoRef.Resolve(cmd.Context(), c, args[0], cmdutil.AllowPrompt(cmd))
			if err != nil {
				return err
			}

			var sshKey *string
			if cmd.Flags().Changed("ssh-key") {
				sshKeyData, readFileErr := os.ReadFile(opts.sshKey)
				if readFileErr != nil {
					return fmt.Errorf("failed to read SSH key file: %w", readFileErr)
				}
				sshKey = new(string(sshKeyData))
			}
			var signingKey *string
			if cmd.Flags().Changed("signing-key") {
				signingKeyValue := ""
				if opts.signingKey != "" {
					signingKeyData, readSigningKeyErr := os.ReadFile(opts.signingKey)
					if readSigningKeyErr != nil {
						return fmt.Errorf("failed to read signing key file: %w", readSigningKeyErr)
					}
					signingKeyValue = string(signingKeyData)
				}
				signingKey = &signingKeyValue
			}

			req := gitops.UpdateRepositoryRequest{
				Name:                   kit.Ternary(cmd.Flags().Changed("name"), &opts.name, nil),
				URL:                    kit.Ternary(cmd.Flags().Changed("url"), &opts.url, nil),
				AuthType:               kit.Ternary(cmd.Flags().Changed("auth-type"), &opts.authType, nil),
				Token:                  kit.Ternary(cmd.Flags().Changed("token"), &opts.token, nil),
				Username:               kit.Ternary(cmd.Flags().Changed("username"), &opts.username, nil),
				SSHHostKeyVerification: kit.Ternary(cmd.Flags().Changed("ssh-host-key-verification"), &opts.sshHostKeyVerify, nil),
				CommitAuthorName:       kit.Ternary(cmd.Flags().Changed("author-name"), &opts.authorName, nil),
				CommitAuthorEmail:      kit.Ternary(cmd.Flags().Changed("author-email"), &opts.authorEmail, nil),
				SigningKeyPassphrase:   kit.Ternary(cmd.Flags().Changed("signing-key-passphrase"), &opts.signingKeyPass, nil),
				Description:            kit.Ternary(cmd.Flags().Changed("description"), &opts.description, nil),
				Enabled:                kit.Ternary(cmd.Flags().Changed("enabled"), &opts.enabled, nil),
				SSHKey:                 sshKey,
				SigningKey:             signingKey,
			}

			return cmdutil.Run(cmd, c, cmdutil.Spec[gitops.GitRepository]{
				Method:         http.MethodPut,
				Path:           types.GitRepository(resolved.ID),
				Body:           req,
				FailureMessage: "failed to update repository",
				Render: func(data gitops.GitRepository) error {
					output.Success("Repository updated successfully")
					output.KeyValue("ID", data.ID)
					output.KeyValue("Name", data.Name)
					output.KeyValue("URL", data.URL)
					output.KeyValue("Auth Type", data.AuthType)
					output.KeyValue("Enabled", data.Enabled)
					return nil
				},
			})
		},
	}
	cmd.Flags().StringVar(&opts.name, "name", "", "Repository name")
	cmd.Flags().StringVar(&opts.url, "url", "", "Repository URL")
	cmdutil.EnumVarP(cmd, cmd.Flags(), &opts.authType, "auth-type", "", "", "Authentication type", "none", "http", "ssh")
	cmd.Flags().StringVar(&opts.token, "token", "", "Token for HTTP authentication")
	cmd.Flags().StringVar(&opts.username, "username", "", "Username for HTTP authentication")
	cmd.Flags().StringVar(&opts.sshKey, "ssh-key", "", "Path to SSH key file")
	cmdutil.EnumVarP(cmd, cmd.Flags(), &opts.sshHostKeyVerify, "ssh-host-key-verification", "", "", "SSH host key verification", "strict", "accept_new", "skip")
	cmd.Flags().StringVar(&opts.authorName, "author-name", "", "Author name for commits Arcane pushes")
	cmd.Flags().StringVar(&opts.authorEmail, "author-email", "", "Author email for commits Arcane pushes")
	cmd.Flags().StringVar(&opts.signingKey, "signing-key", "", "Path to an armored OpenPGP private key used to sign commits (empty clears it)")
	cmd.Flags().StringVar(&opts.signingKeyPass, "signing-key-passphrase", "", "Passphrase for the signing key")
	cmd.Flags().StringVar(&opts.description, "description", "", "Repository description")
	cmd.Flags().BoolVar(&opts.enabled, "enabled", true, "Enable the repository")
	return cmd
}

func newDeleteCmd() *cobra.Command {
	var opts struct {
		force bool
	}
	cmd := &cobra.Command{
		Use:          "delete <repository>",
		Aliases:      []string{"rm", "remove"},
		Short:        "Delete a git repository",
		Args:         cobra.ExactArgs(1),
		SilenceUsage: true,
		RunE: func(cmd *cobra.Command, args []string) error {
			c, err := client.NewFromConfig()
			if err != nil {
				return err
			}

			resolved, _, err := repoRef.Resolve(cmd.Context(), c, args[0], cmdutil.AllowPrompt(cmd))
			if err != nil {
				return err
			}

			return cmdutil.RunDelete(cmd, c, cmdutil.DeleteSpec{
				Force:          opts.force,
				Prompt:         fmt.Sprintf("Are you sure you want to delete repository %s (%s)?", resolved.Name, resolved.ID),
				Path:           types.GitRepository(resolved.ID),
				Body:           nil,
				FailureMessage: "failed to delete repository",
				SuccessMessage: "Repository deleted successfully",
			})
		},
	}
	cmd.Flags().BoolVarP(&opts.force, "force", "f", false, "Force deletion without confirmation")
	return cmd
}

func newTestCmd() *cobra.Command {
	return &cobra.Command{
		Use:          "test <repository>",
		Short:        "Test git repository connection",
		Args:         cobra.ExactArgs(1),
		SilenceUsage: true,
		RunE: func(cmd *cobra.Command, args []string) error {
			c, err := client.NewFromConfig()
			if err != nil {
				return err
			}

			resolved, _, err := repoRef.Resolve(cmd.Context(), c, args[0], cmdutil.AllowPrompt(cmd))
			if err != nil {
				return err
			}

			return cmdutil.Run(cmd, c, cmdutil.Spec[base.MessageResponse]{
				Method:         http.MethodPost,
				Path:           types.GitRepositoryTest(resolved.ID),
				FailureMessage: "repository connection test failed",
				Render: func(base.MessageResponse) error {
					output.Success("%s", "Repository connection test successful")
					return nil
				},
			})
		},
	}
}

func newBranchesCmd() *cobra.Command {
	return &cobra.Command{
		Use:          "branches <repository>",
		Short:        "List branches for a git repository",
		Args:         cobra.ExactArgs(1),
		SilenceUsage: true,
		RunE: func(cmd *cobra.Command, args []string) error {
			c, err := client.NewFromConfig()
			if err != nil {
				return err
			}

			resolved, _, err := repoRef.Resolve(cmd.Context(), c, args[0], cmdutil.AllowPrompt(cmd))
			if err != nil {
				return err
			}

			return cmdutil.Run(cmd, c, cmdutil.Spec[gitops.BranchesResponse]{
				Method:         http.MethodGet,
				Path:           types.GitRepositoryBranches(resolved.ID),
				FailureMessage: "failed to list branches",
				Render: func(data gitops.BranchesResponse) error {
					headers := []string{"BRANCH", "DEFAULT"}
					rows := make([][]string, len(data.Branches))
					for i, branch := range data.Branches {
						isDefault := ""
						if branch.IsDefault {
							isDefault = "*"
						}
						rows[i] = []string{
							branch.Name,
							isDefault,
						}
					}

					if tableErr := output.Table(headers, rows); tableErr != nil {
						return tableErr
					}
					_, _ = fmt.Fprintf(output.Stdout(), "\nTotal: %d branches\n", len(data.Branches))
					return nil
				},
			})
		},
	}
}

func newFilesCmd() *cobra.Command {
	var opts struct {
		branch string
		path   string
	}
	cmd := &cobra.Command{
		Use:          "files <repository>",
		Short:        "List files in a git repository",
		Args:         cobra.ExactArgs(1),
		SilenceUsage: true,
		RunE: func(cmd *cobra.Command, args []string) error {
			c, err := client.NewFromConfig()
			if err != nil {
				return err
			}

			resolved, _, err := repoRef.Resolve(cmd.Context(), c, args[0], cmdutil.AllowPrompt(cmd))
			if err != nil {
				return err
			}

			path := types.GitRepositoryFiles(resolved.ID)
			params := url.Values{}
			if opts.branch != "" {
				params.Set("branch", opts.branch)
			}
			if opts.path != "" {
				params.Set("path", opts.path)
			}
			if len(params) > 0 {
				path = cmdutil.AppendQuery(path, params)
			}

			return cmdutil.Run(cmd, c, cmdutil.Spec[gitops.BrowseResponse]{
				Method:         http.MethodGet,
				Path:           path,
				FailureMessage: "failed to list files",
				Render: func(data gitops.BrowseResponse) error {
					files := data.Files
					headers := []string{"NAME", "TYPE", "PATH", "SIZE"}
					rows := make([][]string, len(files))
					for i, node := range files {
						size := ""
						if node.Type == gitops.FileTreeNodeTypeFile {
							size = strconv.FormatInt(node.Size, 10)
						}
						rows[i] = []string{
							node.Name,
							string(node.Type),
							node.Path,
							size,
						}
					}

					if tableErr := output.Table(headers, rows); tableErr != nil {
						return tableErr
					}
					_, _ = fmt.Fprintf(output.Stdout(), "\nTotal: %d entries\n", len(files))
					return nil
				},
			})
		},
	}
	cmd.Flags().StringVar(&opts.branch, "branch", "", "Branch to browse (required)")
	_ = cmd.MarkFlagRequired("branch")
	cmd.Flags().StringVar(&opts.path, "path", "", "Path within repository")
	return cmd
}

var repoRef = cmdutil.ResourceRef[gitops.GitRepository, gitops.GitRepository]{
	Singular: "repository",
	Plural:   "repositories",
	IDHint:   "the repository ID",
	ListCmd:  "arcane repos list",
	GetPath:  func(_, identifier string) string { return types.GitRepository(identifier) },
	ListPath: func(string) string { return types.GitRepositories() },
	Matches: func(item gitops.GitRepository, identifierLower, original string) bool {
		return strings.EqualFold(item.Name, original) || strings.EqualFold(item.ID, original) ||
			strings.HasPrefix(strings.ToLower(item.ID), identifierLower) || strings.Contains(strings.ToLower(item.Name), identifierLower)
	},
	Label: func(match gitops.GitRepository) string {
		return fmt.Sprintf("%s (%s)", match.Name, match.ID)
	},
	Promote: func(match gitops.GitRepository) *gitops.GitRepository { return &match },
	Exact: func(item gitops.GitRepository, _, original string) bool {
		return strings.EqualFold(item.Name, original) || strings.EqualFold(item.ID, original)
	},
}