redhat-developer · adrianriobo · Dec 1, 2025 · Dec 1, 2025
diff --git a/cmd/mapt/cmd/aws/hosts/fedora.go b/cmd/mapt/cmd/aws/hosts/fedora.go
@@ -97,12 +97,14 @@ func getFedoraDestroy() *cobra.Command {
 				DebugLevel:   viper.GetUint(params.DebugLevel),
 				Serverless:   viper.IsSet(params.Serverless),
 				ForceDestroy: viper.IsSet(params.ForceDestroy),
+				CleanupState: viper.IsSet(params.CleanupState),
 			})
 		},
 	}
 	flagSet := pflag.NewFlagSet(params.DestroyCmdName, pflag.ExitOnError)
 	flagSet.Bool(params.Serverless, false, params.ServerlessDesc)
 	flagSet.Bool(params.ForceDestroy, false, params.ForceDestroyDesc)
+	flagSet.Bool(params.CleanupState, true, params.CleanupStateDesc)
 	c.PersistentFlags().AddFlagSet(flagSet)
 	return c
 }
diff --git a/cmd/mapt/cmd/aws/hosts/mac.go b/cmd/mapt/cmd/aws/hosts/mac.go
@@ -107,14 +107,16 @@ func getMacDestroy() *cobra.Command {
 			}
 			return mac.Destroy(
 				&maptContext.ContextArgs{
-					Debug:      viper.IsSet(params.Debug),
-					DebugLevel: viper.GetUint(params.DebugLevel),
+					Debug:        viper.IsSet(params.Debug),
+					DebugLevel:   viper.GetUint(params.DebugLevel),
+					CleanupState: viper.IsSet(params.CleanupState),
 				},
 				viper.GetString(awsParams.MACDHID))
 		},
 	}
 	flagSet := pflag.NewFlagSet(params.DestroyCmdName, pflag.ExitOnError)
 	flagSet.StringP(awsParams.MACDHID, "", "", awsParams.MACDHIDDesc)
+	flagSet.Bool(params.CleanupState, true, params.CleanupStateDesc)
 	c.PersistentFlags().AddFlagSet(flagSet)
 	err := c.MarkPersistentFlagRequired(awsParams.MACDHID)
 	if err != nil {

diff --git a/cmd/mapt/cmd/aws/hosts/rhel.go b/cmd/mapt/cmd/aws/hosts/rhel.go
@@ -94,16 +94,18 @@ func getRHELDestroy() *cobra.Command {
 				return err
 			}
 			return rhel.Destroy(&maptContext.ContextArgs{
-				ProjectName: viper.GetString(params.ProjectName),
-				BackedURL:   viper.GetString(params.BackedURL),
-				Debug:       viper.IsSet(params.Debug),
-				DebugLevel:  viper.GetUint(params.DebugLevel),
-				Serverless:  viper.IsSet(params.Serverless),
+				ProjectName:  viper.GetString(params.ProjectName),
+				BackedURL:    viper.GetString(params.BackedURL),
+				Debug:        viper.IsSet(params.Debug),
+				DebugLevel:   viper.GetUint(params.DebugLevel),
+				Serverless:   viper.IsSet(params.Serverless),
+				CleanupState: viper.IsSet(params.CleanupState),
 			})
 		},
 	}
 	flagSet := pflag.NewFlagSet(params.DestroyCmdName, pflag.ExitOnError)
 	flagSet.Bool(params.Serverless, false, params.ServerlessDesc)
+	flagSet.Bool(params.CleanupState, true, params.CleanupStateDesc)
 	c.PersistentFlags().AddFlagSet(flagSet)
 	return c
 }
diff --git a/cmd/mapt/cmd/aws/hosts/rhelai.go b/cmd/mapt/cmd/aws/hosts/rhelai.go
@@ -92,12 +92,14 @@ func getRHELAIDestroy() *cobra.Command {
 				DebugLevel:   viper.GetUint(params.DebugLevel),
 				Serverless:   viper.IsSet(params.Serverless),
 				ForceDestroy: viper.IsSet(params.ForceDestroy),
+				CleanupState: viper.IsSet(params.CleanupState),
 			})
 		},
 	}
 	flagSet := pflag.NewFlagSet(params.DestroyCmdName, pflag.ExitOnError)
 	flagSet.Bool(params.Serverless, false, params.ServerlessDesc)
 	flagSet.Bool(params.ForceDestroy, false, params.ForceDestroyDesc)
+	flagSet.Bool(params.CleanupState, true, params.CleanupStateDesc)
 	c.PersistentFlags().AddFlagSet(flagSet)
 	return c
 }
diff --git a/cmd/mapt/cmd/aws/hosts/windows.go b/cmd/mapt/cmd/aws/hosts/windows.go
@@ -101,17 +101,22 @@ func getWindowsDestroy() *cobra.Command {
 		Use:   params.DestroyCmdName,
 		Short: params.DestroyCmdName,
 		RunE: func(cmd *cobra.Command, args []string) error {
+			if err := viper.BindPFlags(cmd.Flags()); err != nil {
+				return err
+			}
 			return windows.Destroy(&maptContext.ContextArgs{
-				ProjectName: viper.GetString(params.ProjectName),
-				BackedURL:   viper.GetString(params.BackedURL),
-				Debug:       viper.IsSet(params.Debug),
-				DebugLevel:  viper.GetUint(params.DebugLevel),
-				Serverless:  viper.IsSet(params.Serverless),
+				ProjectName:  viper.GetString(params.ProjectName),
+				BackedURL:    viper.GetString(params.BackedURL),
+				Debug:        viper.IsSet(params.Debug),
+				DebugLevel:   viper.GetUint(params.DebugLevel),
+				Serverless:   viper.IsSet(params.Serverless),
+				CleanupState: viper.IsSet(params.CleanupState),
 			})
 		},
 	}
 	flagSet := pflag.NewFlagSet(params.DestroyCmdName, pflag.ExitOnError)
 	flagSet.Bool(params.Serverless, false, params.ServerlessDesc)
+	flagSet.Bool(params.CleanupState, true, params.CleanupStateDesc)
 	c.PersistentFlags().AddFlagSet(flagSet)
 	return c
 }
diff --git a/cmd/mapt/cmd/aws/services/eks.go b/cmd/mapt/cmd/aws/services/eks.go
@@ -98,7 +98,7 @@ func getCreateEKS() *cobra.Command {
 }
 
 func getDestroyEKS() *cobra.Command {
-	return &cobra.Command{
+	c := &cobra.Command{
 		Use:   params.DestroyCmdName,
 		Short: params.DestroyCmdName,
 		RunE: func(cmd *cobra.Command, args []string) error {
@@ -107,11 +107,16 @@ func getDestroyEKS() *cobra.Command {
 			}
 			return awsEKS.Destroy(
 				&maptContext.ContextArgs{
-					ProjectName: viper.GetString(params.ProjectName),
-					BackedURL:   viper.GetString(params.BackedURL),
-					Debug:       viper.IsSet(params.Debug),
-					DebugLevel:  viper.GetUint(params.DebugLevel),
+					ProjectName:  viper.GetString(params.ProjectName),
+					BackedURL:    viper.GetString(params.BackedURL),
+					Debug:        viper.IsSet(params.Debug),
+					DebugLevel:   viper.GetUint(params.DebugLevel),
+					CleanupState: viper.IsSet(params.CleanupState),
 				})
 		},
 	}
+	flagSet := pflag.NewFlagSet(params.DestroyCmdName, pflag.ExitOnError)
+	flagSet.Bool(params.CleanupState, true, params.CleanupStateDesc)
+	c.PersistentFlags().AddFlagSet(flagSet)
+	return c
 }
diff --git a/cmd/mapt/cmd/aws/services/kind.go b/cmd/mapt/cmd/aws/services/kind.go
@@ -100,12 +100,14 @@ func destroyKind() *cobra.Command {
 				DebugLevel:   viper.GetUint(params.DebugLevel),
 				Serverless:   viper.IsSet(params.Serverless),
 				ForceDestroy: viper.IsSet(params.ForceDestroy),
+				CleanupState: viper.IsSet(params.CleanupState),
 			})
 		},
 	}
 	flagSet := pflag.NewFlagSet(params.DestroyCmdName, pflag.ExitOnError)
 	flagSet.Bool(params.Serverless, false, params.ServerlessDesc)
 	flagSet.Bool(params.ForceDestroy, false, params.ForceDestroyDesc)
+	flagSet.Bool(params.CleanupState, true, params.CleanupStateDesc)
 	c.PersistentFlags().AddFlagSet(flagSet)
 	return c
 }
diff --git a/cmd/mapt/cmd/aws/services/mac-pool.go b/cmd/mapt/cmd/aws/services/mac-pool.go
@@ -98,15 +98,17 @@ func destroyMP() *cobra.Command {
 				return err
 			}
 			return macpool.Destroy(&maptContext.ContextArgs{
-				ProjectName: viper.GetString(params.ProjectName),
-				BackedURL:   viper.GetString(params.BackedURL),
-				Debug:       viper.IsSet(params.Debug),
-				DebugLevel:  viper.GetUint(params.DebugLevel),
+				ProjectName:  viper.GetString(params.ProjectName),
+				BackedURL:    viper.GetString(params.BackedURL),
+				Debug:        viper.IsSet(params.Debug),
+				DebugLevel:   viper.GetUint(params.DebugLevel),
+				CleanupState: viper.IsSet(params.CleanupState),
 			})
 		},
 	}
 	flagSet := pflag.NewFlagSet(params.CreateCmdName, pflag.ExitOnError)
 	params.AddCommonFlags(flagSet)
+	flagSet.Bool(params.CleanupState, true, params.CleanupStateDesc)
 	c.PersistentFlags().AddFlagSet(flagSet)
 	return c
 }

diff --git a/cmd/mapt/cmd/aws/services/openshift-snc.go b/cmd/mapt/cmd/aws/services/openshift-snc.go
@@ -89,16 +89,18 @@ func destroySNC() *cobra.Command {
 				return err
 			}
 			return openshiftsnc.Destroy(&maptContext.ContextArgs{
-				ProjectName: viper.GetString(params.ProjectName),
-				BackedURL:   viper.GetString(params.BackedURL),
-				Debug:       viper.IsSet(params.Debug),
-				DebugLevel:  viper.GetUint(params.DebugLevel),
-				Serverless:  viper.IsSet(params.Serverless),
+				ProjectName:  viper.GetString(params.ProjectName),
+				BackedURL:    viper.GetString(params.BackedURL),
+				Debug:        viper.IsSet(params.Debug),
+				DebugLevel:   viper.GetUint(params.DebugLevel),
+				Serverless:   viper.IsSet(params.Serverless),
+				CleanupState: viper.IsSet(params.CleanupState),
 			})
 		},
 	}
 	flagSet := pflag.NewFlagSet(params.DestroyCmdName, pflag.ExitOnError)
 	flagSet.Bool(params.Serverless, false, params.ServerlessDesc)
+	flagSet.Bool(params.CleanupState, true, params.CleanupStateDesc)
 	c.PersistentFlags().AddFlagSet(flagSet)
 	return c
 }
diff --git a/cmd/mapt/cmd/params/params.go b/cmd/mapt/cmd/params/params.go
@@ -99,9 +99,11 @@ const (
 	Serverless     string = "serverless"
 	ServerlessDesc string = "if serverless is set the command will be executed as a serverless action."
 
-	// Desytoy
+	// Destroy
 	ForceDestroy     string = "force-destroy"
 	ForceDestroyDesc string = "if force-destroy is set the command will destroy even if there is a lock."
+	CleanupState     string = "cleanup-state"
+	CleanupStateDesc string = "automatically remove Pulumi state files from S3 backend after successful destroy"
 
 	// Kind
 	KindCmd                   = "kind"

diff --git a/pkg/manager/context/context.go b/pkg/manager/context/context.go
@@ -43,6 +43,8 @@ type ContextArgs struct {
 	Serverless bool
 	// This forces destroy even when lock exists
 	ForceDestroy bool
+	// Automatically remove Pulumi state files from backend after successful destroy
+	CleanupState bool
 	// integrations
 	GHRunnerArgs *github.GithubRunnerArgs
 	CirrusPWArgs *cirrus.PersistentWorkerArgs
@@ -57,6 +59,7 @@ type Context struct {
 	debugLevel    uint
 	serverless    bool
 	forceDestroy  bool
+	cleanupState  bool
 	// spotPriceIncreaseRate int
 	tags                  map[string]string
 	tagsAsPulumiStringMap pulumi.StringMap
@@ -83,6 +86,7 @@ func Init(ca *ContextArgs, provider Provider) (*Context, error) {
 		tags:          ca.Tags,
 		serverless:    ca.Serverless,
 		forceDestroy:  ca.ForceDestroy,
+		cleanupState:  ca.CleanupState,
 	}
 	addCommonTags(c)
 	hp, err := provider.DefaultHostingPlace()
@@ -126,6 +130,8 @@ func (c *Context) IsServerless() bool { return c.serverless }
 
 func (c *Context) IsForceDestroy() bool { return c.forceDestroy }
 
+func (c *Context) IsCleanupState() bool { return c.cleanupState }
+
 func (c *Context) TargetHostingPlace() string { return c.targetHostingPlace }
 
 // Get tags ready to be added to any pulumi resource

diff --git a/pkg/provider/aws/action/eks/eks.go b/pkg/provider/aws/action/eks/eks.go
@@ -129,12 +129,17 @@ func Destroy(ctx *mc.ContextArgs) error {
 	if err != nil {
 		return err
 	}
-	return aws.DestroyStack(
+	if err := aws.DestroyStack(
 		mCtx,
 		aws.DestroyStackRequest{
 			BackedURL: mCtx.BackedURL(),
 			Stackname: stackName,
-		})
+		}); err != nil {
+		return err
+	}
+
+	// Cleanup S3 state after all stacks have been destroyed
+	return aws.CleanupState(mCtx)
 }
 
 // Main function to deploy all requried resources to AWS

diff --git a/pkg/provider/aws/action/fedora/fedora.go b/pkg/provider/aws/action/fedora/fedora.go
@@ -127,9 +127,13 @@ func Destroy(c *mc.ContextArgs) (err error) {
 
 	// Destroy spot orchestrated stack
 	if spot.Exist(mCtx) {
-		return spot.Destroy(mCtx)
+		if err := spot.Destroy(mCtx); err != nil {
+			return err
+		}
 	}
-	return nil
+
+	// Cleanup S3 state after all stacks have been destroyed
+	return aws.CleanupState(mCtx)
 }
 
 func (r *fedoraRequest) createMachine() error {

diff --git a/pkg/provider/aws/action/kind/kind.go b/pkg/provider/aws/action/kind/kind.go
@@ -89,9 +89,13 @@ func Destroy(mCtxArgs *mc.ContextArgs) (err error) {
 		return err
 	}
 	if spot.Exist(mCtx) {
-		return spot.Destroy(mCtx)
+		if err := spot.Destroy(mCtx); err != nil {
+			return err
+		}
 	}
-	return nil
+
+	// Cleanup S3 state after all stacks have been destroyed
+	return aws.CleanupState(mCtx)
 }
 
 func (r *kindRequest) createHost() (*utilKind.KindResults, error) {

diff --git a/pkg/provider/aws/action/mac-pool/mac-pool.go b/pkg/provider/aws/action/mac-pool/mac-pool.go
@@ -49,7 +49,12 @@ func Destroy(mCtxArgs *mc.ContextArgs) error {
 	if err := iam.Destroy(mCtx); err != nil {
 		return err
 	}
-	return serverless.Destroy(mCtx)
+	if err := serverless.Destroy(mCtx); err != nil {
+		return err
+	}
+
+	// Cleanup S3 state after all stacks have been destroyed
+	return aws.CleanupState(mCtx)
 }
 
 // House keeper is the function executed serverless to check if is there any

diff --git a/pkg/provider/aws/action/mac/mac.go b/pkg/provider/aws/action/mac/mac.go
@@ -124,14 +124,19 @@ func Destroy(mCtxArgs *mc.ContextArgs, hostID string) error {
 			}); err != nil {
 			return err
 		}
-		return aws.DestroyStack(
+		if err := aws.DestroyStack(
 			mCtx,
 			aws.DestroyStackRequest{
 				Stackname: mac.StackDedicatedHost,
 				// TODO check if needed to add region for backedURL
 				Region:    *hi.Region,
 				BackedURL: *hi.BackedURL,
-			})
+			}); err != nil {
+			return err
+		}
+
+		// Cleanup S3 state after all stacks have been destroyed
+		return aws.CleanupState(mCtx)
 	}
 	logging.Debug("nothing to be destroyed")
 	return nil

diff --git a/pkg/provider/aws/action/openshift-snc/openshift-snc.go b/pkg/provider/aws/action/openshift-snc/openshift-snc.go
@@ -133,9 +133,13 @@ func Destroy(mCtxArgs *mc.ContextArgs) (err error) {
 	}
 	// Destroy spot orchestrated stack
 	if spot.Exist(mCtx) {
-		return spot.Destroy(mCtx)
+		if err := spot.Destroy(mCtx); err != nil {
+			return err
+		}
 	}
-	return nil
+
+	// Cleanup S3 state after all stacks have been destroyed
+	return aws.CleanupState(mCtx)
 }
 
 func (r *openshiftSNCRequest) createCluster() (*OpenshiftSncResultsMetadata, error) {

diff --git a/pkg/provider/aws/action/rhel-ai/rhelai.go b/pkg/provider/aws/action/rhel-ai/rhelai.go
@@ -123,9 +123,13 @@ func Destroy(mCtxArgs *mc.ContextArgs) error {
 		return err
 	}
 	if spot.Exist(mCtx) {
-		return spot.Destroy(mCtx)
+		if err := spot.Destroy(mCtx); err != nil {
+			return err
+		}
 	}
-	return nil
+
+	// Cleanup S3 state after all stacks have been destroyed
+	return aws.CleanupState(mCtx)
 }
 
 func (r *rhelAIRequest) createMachine() error {

diff --git a/pkg/provider/aws/action/rhel/rhel.go b/pkg/provider/aws/action/rhel/rhel.go
@@ -132,9 +132,13 @@ func Destroy(mCtxArgs *mc.ContextArgs) error {
 		return err
 	}
 	if spot.Exist(mCtx) {
-		return spot.Destroy(mCtx)
+		if err := spot.Destroy(mCtx); err != nil {
+			return err
+		}
 	}
-	return nil
+
+	// Cleanup S3 state after all stacks have been destroyed
+	return aws.CleanupState(mCtx)
 }
 
 func (r *rhelRequest) createMachine() error {

diff --git a/pkg/provider/aws/action/windows/windows.go b/pkg/provider/aws/action/windows/windows.go
@@ -181,9 +181,13 @@ func Destroy(mCtxArgs *mc.ContextArgs) (err error) {
 		}
 	}
 	if spot.Exist(mCtx) {
-		return spot.Destroy(mCtx)
+		if err := spot.Destroy(mCtx); err != nil {
+			return err
+		}
 	}
-	return nil
+
+	// Cleanup S3 state after all stacks have been destroyed
+	return aws.CleanupState(mCtx)
 }
 
 func (r *windowsServerRequest) createMachine() error {