cli/packages/cmd/dynamic_secrets.go

/*
Copyright (c) 2024 Hanzo AI Inc.
*/
package cmd

import (
	"context"

	"github.com/hanzokms/cli/packages/api"
	"github.com/hanzokms/cli/packages/config"
	"github.com/hanzokms/cli/packages/visualize"

	// "github.com/hanzokms/cli/packages/models"
	"github.com/hanzokms/cli/packages/util"
	// "github.com/hanzokms/cli/packages/visualize"
	insights "github.com/hanzoai/insights-go"
	"github.com/spf13/cobra"

	kmsSdk "github.com/hanzokms/go-sdk"
	kmsSdkModels "github.com/hanzokms/go-sdk/packages/models"
)

var dynamicSecretCmd = &cobra.Command{
	Example:               `kms dynamic-secrets`,
	Short:                 "Used to list dynamic secrets",
	Use:                   "dynamic-secrets",
	DisableFlagsInUseLine: true,
	Args:                  cobra.NoArgs,
	Run:                   getDynamicSecretList,
}

func getDynamicSecretList(cmd *cobra.Command, args []string) {
	environmentName, _ := cmd.Flags().GetString("env")
	if !cmd.Flags().Changed("env") {
		environmentFromWorkspace := util.GetEnvFromWorkspaceFile()
		if environmentFromWorkspace != "" {
			environmentName = environmentFromWorkspace
		}
	}

	token, err := util.GetKMSToken(cmd)
	if err != nil {
		util.HandleError(err, "Unable to parse flag")
	}

	projectId, err := cmd.Flags().GetString("projectId")
	if err != nil {
		util.HandleError(err, "Unable to parse flag")
	}

	projectSlug, err := cmd.Flags().GetString("project-slug")
	if err != nil {
		util.HandleError(err, "Unable to parse flag")
	}

	secretsPath, err := cmd.Flags().GetString("path")
	if err != nil {
		util.HandleError(err, "Unable to parse path flag")
	}

	outputFormat, err := cmd.Flags().GetString("output")
	if err != nil {
		util.HandleError(err, "Unable to parse flag")
	}

	var kmsToken string
	httpClient, err := util.GetRestyClientWithCustomHeaders()
	if err != nil {
		util.HandleError(err, "Unable to get resty client with custom headers")
	}

	if projectId == "" && projectSlug == "" {
		workspaceFile, err := util.GetWorkSpaceFromFile()
		if err != nil {
			util.PrintErrorMessageAndExit("Please either run kms init to connect to a project, pass in project slug with --project-slug flag, or pass in project id with --projectId flag")
		}
		projectId = workspaceFile.WorkspaceId
	}

	if token != nil && (token.Type == util.SERVICE_TOKEN_IDENTIFIER || token.Type == util.UNIVERSAL_AUTH_TOKEN_IDENTIFIER) {
		kmsToken = token.Token
	} else {
		util.RequireLogin()

		loggedInUserDetails, err := util.GetCurrentLoggedInUserDetails(true)
		if err != nil {
			util.HandleError(err, "Unable to authenticate")
		}

		if loggedInUserDetails.LoginExpired {
			loggedInUserDetails = util.EstablishUserLoginSession()
		}

		kmsToken = loggedInUserDetails.UserCredentials.JTWToken
	}

	httpClient.SetAuthToken(kmsToken)

	customHeaders, err := util.GetKMSCustomHeadersMap()
	if err != nil {
		util.HandleError(err, "Unable to get custom headers")
	}

	kmsClient := kmsSdk.NewClient(context.Background(), kmsSdk.Config{
		SiteUrl:          config.KMS_URL,
		UserAgent:        api.USER_AGENT,
		AutoTokenRefresh: false,
		CustomHeaders:    customHeaders,
	})
	kmsClient.Auth().SetAccessToken(kmsToken)

	if projectSlug == "" {
		projectDetails, err := api.CallGetProjectById(httpClient, projectId)
		if err != nil {
			util.HandleError(err, "To fetch project details")
		}
		projectSlug = projectDetails.Slug
	}

	dynamicSecretRootCredentials, err := kmsClient.DynamicSecrets().List(kmsSdk.ListDynamicSecretsRootCredentialsOptions{
		ProjectSlug:     projectSlug,
		SecretPath:      secretsPath,
		EnvironmentSlug: environmentName,
	})

	if err != nil {
		util.HandleError(err, "To fetch dynamic secret root credentials details")
	}

	if outputFormat != "" {
		output, err := util.FormatOutput(outputFormat, dynamicSecretRootCredentials, nil)
		if err != nil {
			util.HandleError(err, "Unable to format output")
		}
		util.PrintStdout(output)
	} else {
		visualize.PrintAllDynamicRootCredentials(dynamicSecretRootCredentials)
	}
	Telemetry.CaptureEvent("cli-command:dynamic-secrets", insights.NewProperties().Set("count", len(dynamicSecretRootCredentials)).Set("version", util.CLI_VERSION))
}

var dynamicSecretLeaseCmd = &cobra.Command{
	Example:               `lease`,
	Short:                 "Manage leases for dynamic secrets",
	Use:                   "lease",
	DisableFlagsInUseLine: true,
}

var dynamicSecretLeaseCreateCmd = &cobra.Command{
	Example:               `lease create <dynamic secret name>"`,
	Short:                 "Used to lease dynamic secret by name",
	Use:                   "create [dynamic-secret]",
	DisableFlagsInUseLine: true,
	Args:                  cobra.ExactArgs(1),
	Run:                   createDynamicSecretLeaseByName,
}

func createDynamicSecretLeaseByName(cmd *cobra.Command, args []string) {
	dynamicSecretRootCredentialName := args[0]

	environmentName, _ := cmd.Flags().GetString("env")
	if !cmd.Flags().Changed("env") {
		environmentFromWorkspace := util.GetEnvFromWorkspaceFile()
		if environmentFromWorkspace != "" {
			environmentName = environmentFromWorkspace
		}
	}

	token, err := util.GetKMSToken(cmd)
	if err != nil {
		util.HandleError(err, "Unable to parse flag")
	}

	projectId, err := cmd.Flags().GetString("projectId")
	if err != nil {
		util.HandleError(err, "Unable to parse flag")
	}

	projectSlug, err := cmd.Flags().GetString("project-slug")
	if err != nil {
		util.HandleError(err, "Unable to parse flag")
	}

	ttl, err := cmd.Flags().GetString("ttl")
	if err != nil {
		util.HandleError(err, "Unable to parse flag")
	}

	secretsPath, err := cmd.Flags().GetString("path")
	if err != nil {
		util.HandleError(err, "Unable to parse path flag")
	}

	plainOutput, err := cmd.Flags().GetBool("plain")
	if err != nil {
		util.HandleError(err, "Unable to parse flag")
	}

	outputFormat, err := cmd.Flags().GetString("output")
	if err != nil {
		util.HandleError(err, "Unable to parse flag")
	}

	var kmsToken string
	httpClient, err := util.GetRestyClientWithCustomHeaders()
	if err != nil {
		util.HandleError(err, "Unable to get resty client with custom headers")
	}

	if projectId == "" && projectSlug == "" {
		workspaceFile, err := util.GetWorkSpaceFromFile()
		if err != nil {
			util.PrintErrorMessageAndExit("Please either run kms init to connect to a project, pass in project id with --projectId flag, or pass in project slug with --project-slug flag")
		}
		projectId = workspaceFile.WorkspaceId
	}

	if token != nil && (token.Type == util.SERVICE_TOKEN_IDENTIFIER || token.Type == util.UNIVERSAL_AUTH_TOKEN_IDENTIFIER) {
		kmsToken = token.Token
	} else {
		util.RequireLogin()

		loggedInUserDetails, err := util.GetCurrentLoggedInUserDetails(true)
		if err != nil {
			util.HandleError(err, "Unable to authenticate")
		}

		if loggedInUserDetails.LoginExpired {
			loggedInUserDetails = util.EstablishUserLoginSession()
		}
		kmsToken = loggedInUserDetails.UserCredentials.JTWToken
	}

	httpClient.SetAuthToken(kmsToken)

	customHeaders, err := util.GetKMSCustomHeadersMap()
	if err != nil {
		util.HandleError(err, "Unable to get custom headers")
	}

	kmsClient := kmsSdk.NewClient(context.Background(), kmsSdk.Config{
		SiteUrl:          config.KMS_URL,
		UserAgent:        api.USER_AGENT,
		AutoTokenRefresh: false,
		CustomHeaders:    customHeaders,
	})
	kmsClient.Auth().SetAccessToken(kmsToken)

	if projectSlug == "" {
		projectDetails, err := api.CallGetProjectById(httpClient, projectId)
		if err != nil {
			util.HandleError(err, "To fetch project details")
		}
		projectSlug = projectDetails.Slug
	}

	dynamicSecretRootCredential, err := kmsClient.DynamicSecrets().GetByName(kmsSdk.GetDynamicSecretRootCredentialByNameOptions{
		DynamicSecretName: dynamicSecretRootCredentialName,
		ProjectSlug:       projectSlug,
		SecretPath:        secretsPath,
		EnvironmentSlug:   environmentName,
	})

	if err != nil {
		util.HandleError(err, "To fetch dynamic secret root credentials details")
	}

	// for Kubernetes dynamic secrets only
	kubernetesNamespace, err := cmd.Flags().GetString("kubernetes-namespace")
	if err != nil {
		util.HandleError(err, "Unable to parse flag")
	}

	config := map[string]any{}
	if kubernetesNamespace != "" {
		config["namespace"] = kubernetesNamespace
	}

	leaseCredentials, _, leaseDetails, err := kmsClient.DynamicSecrets().Leases().Create(kmsSdk.CreateDynamicSecretLeaseOptions{
		DynamicSecretName: dynamicSecretRootCredential.Name,
		ProjectSlug:       projectSlug,
		TTL:               ttl,
		SecretPath:        secretsPath,
		EnvironmentSlug:   environmentName,
		Config:            config,
	})

	if err != nil {
		util.HandleError(err, "To lease dynamic secret")
	}

	if outputFormat != "" {

		output, err := util.FormatOutput(outputFormat, leaseCredentials, nil)
		if err != nil {
			util.HandleError(err, "Unable to format output")
		}
		util.PrintStdout(output)
	} else {
		// plain output is deprecated is replaced by output=dotenv format, but remains for backwards compatibility
		if plainOutput {
			for key, value := range leaseCredentials {
				if cred, ok := value.(string); ok {
					util.PrintfStdout("%s=%s\n", key, cred)
				}
			}
		} else {
			util.PrintlnStderr("Dynamic Secret Leasing")
			util.PrintfStderr("Name: %s\n", dynamicSecretRootCredential.Name)
			util.PrintfStderr("Provider: %s\n", dynamicSecretRootCredential.Type)
			util.PrintfStderr("Lease ID: %s\n", leaseDetails.Id)
			util.PrintfStderr("Expire At: %s\n", leaseDetails.ExpireAt.Local().Format("02-Jan-2006 03:04:05 PM"))
			visualize.PrintAllDyamicSecretLeaseCredentials(leaseCredentials)
		}
	}

	Telemetry.CaptureEvent("cli-command:dynamic-secrets lease", insights.NewProperties().Set("type", dynamicSecretRootCredential.Type).Set("version", util.CLI_VERSION))
}

var dynamicSecretLeaseRenewCmd = &cobra.Command{
	Example:               `lease renew <dynamic secret name>"`,
	Short:                 "Used to renew dynamic secret lease by name",
	Use:                   "renew [lease-id]",
	DisableFlagsInUseLine: true,
	Args:                  cobra.ExactArgs(1),
	Run:                   renewDynamicSecretLeaseByName,
}

func renewDynamicSecretLeaseByName(cmd *cobra.Command, args []string) {
	dynamicSecretLeaseId := args[0]

	environmentName, _ := cmd.Flags().GetString("env")
	if !cmd.Flags().Changed("env") {
		environmentFromWorkspace := util.GetEnvFromWorkspaceFile()
		if environmentFromWorkspace != "" {
			environmentName = environmentFromWorkspace
		}
	}

	token, err := util.GetKMSToken(cmd)
	if err != nil {
		util.HandleError(err, "Unable to parse flag")
	}

	projectId, err := cmd.Flags().GetString("projectId")
	if err != nil {
		util.HandleError(err, "Unable to parse flag")
	}

	projectSlug, err := cmd.Flags().GetString("project-slug")
	if err != nil {
		util.HandleError(err, "Unable to parse flag")
	}

	ttl, err := cmd.Flags().GetString("ttl")
	if err != nil {
		util.HandleError(err, "Unable to parse flag")
	}

	secretsPath, err := cmd.Flags().GetString("path")
	if err != nil {
		util.HandleError(err, "Unable to parse path flag")
	}

	outputFormat, err := cmd.Flags().GetString("output")
	if err != nil {
		util.HandleError(err, "Unable to parse flag")
	}

	var kmsToken string
	httpClient, err := util.GetRestyClientWithCustomHeaders()
	if err != nil {
		util.HandleError(err, "Unable to get resty client with custom headers")
	}

	if projectId == "" && projectSlug == "" {
		workspaceFile, err := util.GetWorkSpaceFromFile()
		if err != nil {
			util.PrintErrorMessageAndExit("Please either run kms init to connect to a project, pass in project slug with --project-slug flag, or pass in project id with --projectId flag")
		}
		projectId = workspaceFile.WorkspaceId
	}

	if token != nil && (token.Type == util.SERVICE_TOKEN_IDENTIFIER || token.Type == util.UNIVERSAL_AUTH_TOKEN_IDENTIFIER) {
		kmsToken = token.Token
	} else {
		util.RequireLogin()

		loggedInUserDetails, err := util.GetCurrentLoggedInUserDetails(true)
		if err != nil {
			util.HandleError(err, "Unable to authenticate")
		}

		if loggedInUserDetails.LoginExpired {
			loggedInUserDetails = util.EstablishUserLoginSession()
		}

		kmsToken = loggedInUserDetails.UserCredentials.JTWToken
	}

	httpClient.SetAuthToken(kmsToken)

	customHeaders, err := util.GetKMSCustomHeadersMap()
	if err != nil {
		util.HandleError(err, "Unable to get custom headers")
	}

	kmsClient := kmsSdk.NewClient(context.Background(), kmsSdk.Config{
		SiteUrl:          config.KMS_URL,
		UserAgent:        api.USER_AGENT,
		AutoTokenRefresh: false,
		CustomHeaders:    customHeaders,
	})
	kmsClient.Auth().SetAccessToken(kmsToken)

	if projectSlug == "" {
		projectDetails, err := api.CallGetProjectById(httpClient, projectId)
		if err != nil {
			util.HandleError(err, "To fetch project details")
		}
		projectSlug = projectDetails.Slug
	}

	if err != nil {
		util.HandleError(err, "To fetch dynamic secret root credentials details")
	}

	leaseDetails, err := kmsClient.DynamicSecrets().Leases().RenewById(kmsSdk.RenewDynamicSecretLeaseOptions{
		ProjectSlug:     projectSlug,
		TTL:             ttl,
		SecretPath:      secretsPath,
		EnvironmentSlug: environmentName,
		LeaseId:         dynamicSecretLeaseId,
	})
	if err != nil {
		util.HandleError(err, "To renew dynamic secret lease")
	}

	if outputFormat != "" {

		output, err := util.FormatOutput(outputFormat, leaseDetails, nil)
		if err != nil {
			util.HandleError(err, "Unable to format output")
		}
		util.PrintStdout(output)
	} else {

		util.PrintlnStderr("Successfully renewed dynamic secret lease")
		visualize.PrintAllDynamicSecretLeases([]kmsSdkModels.DynamicSecretLease{leaseDetails})
	}

	Telemetry.CaptureEvent("cli-command:dynamic-secrets lease renew", insights.NewProperties().Set("version", util.CLI_VERSION))
}

var dynamicSecretLeaseRevokeCmd = &cobra.Command{
	Example:               `lease delete <dynamic secret name>"`,
	Short:                 "Used to delete dynamic secret lease by name",
	Use:                   "delete [lease-id]",
	DisableFlagsInUseLine: true,
	Args:                  cobra.ExactArgs(1),
	Run:                   revokeDynamicSecretLeaseByName,
}

func revokeDynamicSecretLeaseByName(cmd *cobra.Command, args []string) {
	dynamicSecretLeaseId := args[0]

	environmentName, _ := cmd.Flags().GetString("env")
	if !cmd.Flags().Changed("env") {
		environmentFromWorkspace := util.GetEnvFromWorkspaceFile()
		if environmentFromWorkspace != "" {
			environmentName = environmentFromWorkspace
		}
	}

	token, err := util.GetKMSToken(cmd)
	if err != nil {
		util.HandleError(err, "Unable to parse flag")
	}

	projectId, err := cmd.Flags().GetString("projectId")
	if err != nil {
		util.HandleError(err, "Unable to parse flag")
	}

	projectSlug, err := cmd.Flags().GetString("project-slug")
	if err != nil {
		util.HandleError(err, "Unable to parse flag")
	}

	secretsPath, err := cmd.Flags().GetString("path")
	if err != nil {
		util.HandleError(err, "Unable to parse path flag")
	}

	outputFormat, err := cmd.Flags().GetString("output")
	if err != nil {
		util.HandleError(err, "Unable to parse flag")
	}

	var kmsToken string
	httpClient, err := util.GetRestyClientWithCustomHeaders()
	if err != nil {
		util.HandleError(err, "Unable to get resty client with custom headers")
	}

	if projectId == "" && projectSlug == "" {
		workspaceFile, err := util.GetWorkSpaceFromFile()
		if err != nil {
			util.PrintErrorMessageAndExit("Please either run kms init to connect to a project, pass in project slug with --project-slug flag, or pass in project id with --projectId flag")
		}
		projectId = workspaceFile.WorkspaceId
	}

	if token != nil && (token.Type == util.SERVICE_TOKEN_IDENTIFIER || token.Type == util.UNIVERSAL_AUTH_TOKEN_IDENTIFIER) {
		kmsToken = token.Token
	} else {
		util.RequireLogin()

		loggedInUserDetails, err := util.GetCurrentLoggedInUserDetails(true)
		if err != nil {
			util.HandleError(err, "Unable to authenticate")
		}

		if loggedInUserDetails.LoginExpired {
			loggedInUserDetails = util.EstablishUserLoginSession()
		}

		kmsToken = loggedInUserDetails.UserCredentials.JTWToken
	}

	httpClient.SetAuthToken(kmsToken)

	customHeaders, err := util.GetKMSCustomHeadersMap()
	if err != nil {
		util.HandleError(err, "Unable to get custom headers")
	}

	kmsClient := kmsSdk.NewClient(context.Background(), kmsSdk.Config{
		SiteUrl:          config.KMS_URL,
		UserAgent:        api.USER_AGENT,
		AutoTokenRefresh: false,
		CustomHeaders:    customHeaders,
	})
	kmsClient.Auth().SetAccessToken(kmsToken)

	if projectSlug == "" {
		projectDetails, err := api.CallGetProjectById(httpClient, projectId)
		if err != nil {
			util.HandleError(err, "To fetch project details")
		}
		projectSlug = projectDetails.Slug
	}

	if err != nil {
		util.HandleError(err, "To fetch dynamic secret root credentials details")
	}

	leaseDetails, err := kmsClient.DynamicSecrets().Leases().DeleteById(kmsSdk.DeleteDynamicSecretLeaseOptions{
		ProjectSlug:     projectSlug,
		SecretPath:      secretsPath,
		EnvironmentSlug: environmentName,
		LeaseId:         dynamicSecretLeaseId,
	})
	if err != nil {
		util.HandleError(err, "To revoke  dynamic secret lease")
	}

	if outputFormat != "" {
		output, err := util.FormatOutput(outputFormat, leaseDetails, nil)
		if err != nil {
			util.HandleError(err, "Unable to format output")
		}
		util.PrintStdout(output)
	} else {

		util.PrintlnStderr("Successfully revoked dynamic secret lease")
		visualize.PrintAllDynamicSecretLeases([]kmsSdkModels.DynamicSecretLease{leaseDetails})
	}

	Telemetry.CaptureEvent("cli-command:dynamic-secrets lease revoke", insights.NewProperties().Set("version", util.CLI_VERSION))
}

var dynamicSecretLeaseListCmd = &cobra.Command{
	Example:               `lease list <dynamic secret name>"`,
	Short:                 "Used to list leases of a dynamic secret by name",
	Use:                   "list [dynamic-secret]",
	DisableFlagsInUseLine: true,
	Args:                  cobra.ExactArgs(1),
	Run:                   listDynamicSecretLeaseByName,
}

func listDynamicSecretLeaseByName(cmd *cobra.Command, args []string) {
	dynamicSecretRootCredentialName := args[0]

	environmentName, _ := cmd.Flags().GetString("env")
	if !cmd.Flags().Changed("env") {
		environmentFromWorkspace := util.GetEnvFromWorkspaceFile()
		if environmentFromWorkspace != "" {
			environmentName = environmentFromWorkspace
		}
	}

	token, err := util.GetKMSToken(cmd)
	if err != nil {
		util.HandleError(err, "Unable to parse flag")
	}

	projectId, err := cmd.Flags().GetString("projectId")
	if err != nil {
		util.HandleError(err, "Unable to parse flag")
	}

	projectSlug, err := cmd.Flags().GetString("project-slug")
	if err != nil {
		util.HandleError(err, "Unable to parse flag")
	}

	secretsPath, err := cmd.Flags().GetString("path")
	if err != nil {
		util.HandleError(err, "Unable to parse path flag")
	}

	outputFormat, err := cmd.Flags().GetString("output")
	if err != nil {
		util.HandleError(err, "Unable to parse flag")
	}

	var kmsToken string
	httpClient, err := util.GetRestyClientWithCustomHeaders()
	if err != nil {
		util.HandleError(err, "Unable to get resty client with custom headers")
	}

	if projectId == "" && projectSlug == "" {
		workspaceFile, err := util.GetWorkSpaceFromFile()
		if err != nil {
			util.PrintErrorMessageAndExit("Please either run kms init to connect to a project, pass in project slug with --project-slug flag, or pass in project id with --projectId flag")
		}
		projectId = workspaceFile.WorkspaceId
	}

	if token != nil && (token.Type == util.SERVICE_TOKEN_IDENTIFIER || token.Type == util.UNIVERSAL_AUTH_TOKEN_IDENTIFIER) {
		kmsToken = token.Token
	} else {
		util.RequireLogin()

		loggedInUserDetails, err := util.GetCurrentLoggedInUserDetails(true)
		if err != nil {
			util.HandleError(err, "Unable to authenticate")
		}

		if loggedInUserDetails.LoginExpired {
			loggedInUserDetails = util.EstablishUserLoginSession()
		}
		kmsToken = loggedInUserDetails.UserCredentials.JTWToken
	}

	httpClient.SetAuthToken(kmsToken)

	customHeaders, err := util.GetKMSCustomHeadersMap()
	if err != nil {
		util.HandleError(err, "Unable to get custom headers")
	}

	kmsClient := kmsSdk.NewClient(context.Background(), kmsSdk.Config{
		SiteUrl:          config.KMS_URL,
		UserAgent:        api.USER_AGENT,
		AutoTokenRefresh: false,
		CustomHeaders:    customHeaders,
	})
	kmsClient.Auth().SetAccessToken(kmsToken)

	if projectSlug == "" {
		projectDetails, err := api.CallGetProjectById(httpClient, projectId)
		if err != nil {
			util.HandleError(err, "To fetch project details")
		}
		projectSlug = projectDetails.Slug
	}

	dynamicSecretLeases, err := kmsClient.DynamicSecrets().Leases().List(kmsSdk.ListDynamicSecretLeasesOptions{
		DynamicSecretName: dynamicSecretRootCredentialName,
		ProjectSlug:       projectSlug,
		SecretPath:        secretsPath,
		EnvironmentSlug:   environmentName,
	})

	if err != nil {
		util.HandleError(err, "To fetch dynamic secret leases list")
	}

	if outputFormat != "" {
		output, err := util.FormatOutput(outputFormat, dynamicSecretLeases, nil)
		if err != nil {
			util.HandleError(err, "Unable to format output")
		}
		util.PrintStdout(output)
	} else {
		visualize.PrintAllDynamicSecretLeases(dynamicSecretLeases)
	}

	Telemetry.CaptureEvent("cli-command:dynamic-secrets lease list", insights.NewProperties().Set("lease-count", len(dynamicSecretLeases)).Set("version", util.CLI_VERSION))
}

func init() {
	dynamicSecretLeaseCreateCmd.Flags().StringP("path", "p", "/", "The path from where dynamic secret should be leased from")
	dynamicSecretLeaseCreateCmd.Flags().String("token", "", "Create dynamic secret leases using machine identity access token")
	dynamicSecretLeaseCreateCmd.Flags().String("projectId", "", "Manually set the projectId to fetch leased from when using machine identity based auth")
	dynamicSecretLeaseCreateCmd.Flags().String("project-slug", "", "Manually set the project-slug to create lease in")
	dynamicSecretLeaseCreateCmd.Flags().String("ttl", "", "The lease lifetime TTL. If not provided the default TTL of dynamic secret will be used.")
	dynamicSecretLeaseCreateCmd.Flags().Bool("plain", false, "Print leased credentials without formatting, one per line")

	// Add output flags
	util.AddOutputFlagsToCmd(dynamicSecretLeaseCreateCmd, "The output to format the leased credentials in.")

	// Kubernetes specific flags
	dynamicSecretLeaseCreateCmd.Flags().String("kubernetes-namespace", "", "The namespace to create the lease in. Only used for Kubernetes dynamic secrets.")

	dynamicSecretLeaseCmd.AddCommand(dynamicSecretLeaseCreateCmd)

	dynamicSecretLeaseListCmd.Flags().StringP("path", "p", "/", "The path from where dynamic secret should be leased from")
	dynamicSecretLeaseListCmd.Flags().String("token", "", "Fetch dynamic secret leases machine identity access token")
	dynamicSecretLeaseListCmd.Flags().String("projectId", "", "Manually set the projectId to fetch leased from when using machine identity based auth")
	dynamicSecretLeaseListCmd.Flags().String("project-slug", "", "Manually set the project-slug to list leases from")
	util.AddOutputFlagsToCmd(dynamicSecretLeaseListCmd, "The output to format the dynamic secret leases in.")
	dynamicSecretLeaseCmd.AddCommand(dynamicSecretLeaseListCmd)

	dynamicSecretLeaseRenewCmd.Flags().StringP("path", "p", "/", "The path from where dynamic secret should be leased from")
	dynamicSecretLeaseRenewCmd.Flags().String("token", "", "Renew dynamic secrets machine identity access token")
	dynamicSecretLeaseRenewCmd.Flags().String("projectId", "", "Manually set the projectId to fetch leased from when using machine identity based auth")
	dynamicSecretLeaseRenewCmd.Flags().String("project-slug", "", "Manually set the project-slug to renew lease in")
	dynamicSecretLeaseRenewCmd.Flags().String("ttl", "", "The lease lifetime TTL. If not provided the default TTL of dynamic secret will be used.")
	util.AddOutputFlagsToCmd(dynamicSecretLeaseRenewCmd, "The output to format the dynamic secret lease renewal in.")
	dynamicSecretLeaseCmd.AddCommand(dynamicSecretLeaseRenewCmd)

	dynamicSecretLeaseRevokeCmd.Flags().StringP("path", "p", "/", "The path from where dynamic secret should be leased from")
	dynamicSecretLeaseRevokeCmd.Flags().String("token", "", "Delete dynamic secrets using machine identity access token")
	dynamicSecretLeaseRevokeCmd.Flags().String("projectId", "", "Manually set the projectId to fetch leased from when using machine identity based auth")
	dynamicSecretLeaseRevokeCmd.Flags().String("project-slug", "", "Manually set the project-slug to revoke lease from")
	util.AddOutputFlagsToCmd(dynamicSecretLeaseRevokeCmd, "The output to format the dynamic secret lease revocation in.")
	dynamicSecretLeaseCmd.AddCommand(dynamicSecretLeaseRevokeCmd)

	dynamicSecretCmd.AddCommand(dynamicSecretLeaseCmd)

	dynamicSecretCmd.Flags().String("token", "", "Fetch secrets using service token or machine identity access token")
	dynamicSecretCmd.Flags().String("projectId", "", "Manually set the projectId to fetch dynamic-secret when using machine identity based auth")
	dynamicSecretCmd.Flags().String("project-slug", "", "Manually set the project-slug to fetch dynamic-secret from")
	dynamicSecretCmd.PersistentFlags().String("env", "dev", "Used to select the environment name on which actions should be taken on")
	dynamicSecretCmd.Flags().String("path", "/", "get dynamic secret within a folder path")
	util.AddOutputFlagsToCmd(dynamicSecretCmd, "The output to format the dynamic secrets in.")
	RootCmd.AddCommand(dynamicSecretCmd)
}