updates

Author: vegeris

cmd/app/delete.go

@@ -111,7 +111,7 @@ func RunDeleteCommand(ctx context.Context, clients *shared.ClientFactory, cmd *c
 func confirmDeletion(ctx context.Context, IO iostreams.IOStreamer, app prompts.SelectedApp) (bool, error) {
 	IO.PrintInfo(ctx, false, "\n%s", style.Sectionf(style.TextSection{
 		Emoji: "warning",
-		Text:  style.Bold(" Danger zone"),
+		Text:  style.Bold("Danger zone"),
 		Secondary: []string{
 			fmt.Sprintf("App (%s) will be permanently deleted", app.App.AppID),
 			"All triggers, workflows, and functions will be deleted",

cmd/sandbox/create.go

@@ -22,39 +22,36 @@ import (
 	"time"
 
 	"github.com/slackapi/slack-cli/internal/shared"
-	"github.com/slackapi/slack-cli/internal/shared/types"
 	"github.com/slackapi/slack-cli/internal/slackerror"
 	"github.com/slackapi/slack-cli/internal/style"
 	"github.com/spf13/cobra"
 )
 
 type createFlags struct {
-	name        string
-	domain      string
-	password    string
-	locale      string
-	owningOrgID string
-	template    string
-	eventCode   string
-	ttl         string
-	autoLogin   bool
-	output      string
-	token       string
+	name           string
+	domain         string
+	password       string
+	locale         string
+	owningOrgID    string
+	template       string
+	demoIDs        []string
+	eventCode      string
+	archiveDate    string // TTL duration, e.g. 1d, 2h
+	archiveDateStr string // explicit date yyyy-mm-dd
+	output         string
 }
 
 var createCmdFlags createFlags
 
 func NewCreateCommand(clients *shared.ClientFactory) *cobra.Command {
 	cmd := &cobra.Command{
 		Use:   "create [flags]",
-		Short: "Create a new sandbox",
-		Long: `Create a new Slack developer sandbox.
-
-Provisions a new sandbox. Domain is derived from org name if --domain is not provided.`,
+		Short: "Create a developer sandbox",
+		Long:  `Create a new Slack developer sandbox`,
 		Example: style.ExampleCommandsf([]style.ExampleCommand{
-			{Command: "sandbox create --name test-box", Meaning: "Create a sandbox named test-box"},
-			{Command: "sandbox create --name test-box --password mypass --owning-org-id E12345", Meaning: "Create a sandbox with login password and owning org"},
-			{Command: "sandbox create --name test-box --domain test-box --ttl 24h --output json", Meaning: "Create an ephemeral sandbox for CI/CD with JSON output"},
+			{Command: "sandbox create --name test-box --password mypass", Meaning: "Create a sandbox named test-box"},
+			{Command: "sandbox create --name test-box --password mypass --domain test-box --archive 1d", Meaning: "Create a temporary sandbox that will be archived in 1 day"},
+			{Command: "sandbox create --name test-box --password mypass --domain test-box --archive-date 2025-12-31", Meaning: "Create a sandbox that will be archived on a specific date"},
 		}),
 		Args: cobra.NoArgs,
 		PreRunE: func(cmd *cobra.Command, args []string) error {
@@ -68,24 +65,33 @@ Provisions a new sandbox. Domain is derived from org name if --domain is not pro
 	cmd.Flags().StringVar(&createCmdFlags.name, "name", "", "Organization name for the new sandbox")
 	cmd.Flags().StringVar(&createCmdFlags.domain, "domain", "", "Team domain (e.g., pizzaknifefight). If not provided, derived from org name")
 	cmd.Flags().StringVar(&createCmdFlags.password, "password", "", "Password used to log into the sandbox")
-	cmd.Flags().StringVar(&createCmdFlags.owningOrgID, "owning-org-id", "", "Enterprise team ID that manages your developer account, if applicable")
 	cmd.Flags().StringVar(&createCmdFlags.template, "template", "", "Template ID for pre-defined data to preload")
+	cmd.Flags().StringSliceVar(&createCmdFlags.demoIDs, "demo-ids", nil, "Demo IDs to preload in the sandbox")
 	cmd.Flags().StringVar(&createCmdFlags.eventCode, "event-code", "", "Event code for the sandbox")
-	cmd.Flags().StringVar(&createCmdFlags.ttl, "ttl", "", "Time-to-live duration; sandbox will be archived after this period (e.g., 2h, 1d, 7d)")
+	cmd.Flags().StringVar(&createCmdFlags.archiveDate, "archive", "", "Time-to-live duration; sandbox will be archived after this period (e.g., 2h, 1d, 7d)")
+	cmd.Flags().StringVar(&createCmdFlags.archiveDateStr, "archive-date", "", "Explicit archive date in yyyy-mm-dd format. Cannot be used with --archive")
 	cmd.Flags().StringVar(&createCmdFlags.output, "output", "text", "Output format: json, text")
-	cmd.Flags().StringVar(&createCmdFlags.token, "token", "", "Service account token for CI/CD authentication")
 
-	cmd.MarkFlagRequired("name")
-	cmd.MarkFlagRequired("domain")
-	cmd.MarkFlagRequired("password")
+	// If one's developer account is managed by multiple Production Slack teams, one of those team IDs must be provided in the command
+	cmd.Flags().StringVar(&createCmdFlags.owningOrgID, "owning-org-id", "", "Enterprise team ID that manages your developer account, if applicable")
+
+	if err := cmd.MarkFlagRequired("name"); err != nil {
+		panic(err)
+	}
+	if err := cmd.MarkFlagRequired("domain"); err != nil {
+		panic(err)
+	}
+	if err := cmd.MarkFlagRequired("password"); err != nil {
+		panic(err)
+	}
 
 	return cmd
 }
 
 func runCreateCommand(cmd *cobra.Command, clients *shared.ClientFactory) error {
 	ctx := cmd.Context()
 
-	token, err := getSandboxToken(ctx, clients, createCmdFlags.token)
+	auth, err := getSandboxAuth(ctx, clients)
 	if err != nil {
 		return err
 	}
@@ -95,12 +101,18 @@ func runCreateCommand(cmd *cobra.Command, clients *shared.ClientFactory) error {
 		domain = slugFromsandboxName(createCmdFlags.name)
 	}
 
-	archiveDate, err := ttlToArchiveDate(createCmdFlags.ttl)
+	if createCmdFlags.archiveDate != "" && createCmdFlags.archiveDateStr != "" {
+		return slackerror.New(slackerror.ErrInvalidArguments).
+			WithMessage("Cannot use both --archive and --archive-date").
+			WithRemediation("Use only one: --archive for TTL (e.g., 1d) or --archive-date for a specific date (yyyy-mm-dd)")
+	}
+
+	archiveDate, err := getArchiveDateEpoch(createCmdFlags.archiveDate, createCmdFlags.archiveDateStr)
 	if err != nil {
 		return err
 	}
 
-	result, err := clients.API().CreateSandbox(ctx, token,
+	teamID, sandboxURL, err := clients.API().CreateSandbox(ctx, auth.Token,
 		createCmdFlags.name,
 		domain,
 		createCmdFlags.password,
@@ -118,29 +130,37 @@ func runCreateCommand(cmd *cobra.Command, clients *shared.ClientFactory) error {
 	case "json":
 		encoder := json.NewEncoder(clients.IO.WriteOut())
 		encoder.SetIndent("", "  ")
-		if err := encoder.Encode(result); err != nil {
+		if err := encoder.Encode(map[string]string{"team_id": teamID, "url": sandboxURL}); err != nil {
 			return err
 		}
 	default:
-		printCreateSuccess(cmd, clients, result)
-	}
-
-	if createCmdFlags.autoLogin && result.URL != "" {
-		clients.Browser().OpenURL(result.URL)
+		printCreateSuccess(cmd, clients, teamID, sandboxURL)
 	}
 
 	return nil
 }
 
 const maxTTL = 180 * 24 * time.Hour // 6 months
 
-// ttlToArchiveDate parses a TTL string (e.g., "24h", "1d", "7d") and returns the Unix epoch
-// when the sandbox will be archived. Returns 0 if ttl is empty (no archiving). Supports
-// Go duration format (h, m, s) and "Nd" for days. TTL cannot exceed 6 months.
-func ttlToArchiveDate(ttl string) (int64, error) {
-	if ttl == "" {
-		return 0, nil
+const archiveDateFormat = "2006-01-02"
+
+// getArchiveDateEpoch returns the Unix epoch when the sandbox will be archived.
+// It accepts either a TTL string (--archive) or an explicit date (--archive-date).
+// Returns 0 if neither is provided.
+func getArchiveDateEpoch(ttl, dateStr string) (int64, error) {
+	if ttl != "" {
+		return getArchiveDateFromTTL(ttl)
+	}
+	if dateStr != "" {
+		return getArchiveDateFromDate(dateStr)
 	}
+	return 0, nil
+}
+
+// getArchiveDateFromTTL parses a time-to-live string (e.g., "24h", "1d", "7d") and returns the Unix epoch
+// when the sandbox will be archived. Supports Go duration format (h, m, s) and "Nd" for days.
+// The value cannot exceed 6 months.
+func getArchiveDateFromTTL(ttl string) (int64, error) {
 	var d time.Duration
 	if strings.HasSuffix(strings.ToLower(ttl), "d") {
 		numStr := strings.TrimSuffix(strings.ToLower(ttl), "d")
@@ -168,6 +188,17 @@ func ttlToArchiveDate(ttl string) (int64, error) {
 	return time.Now().Add(d).Unix(), nil
 }
 
+// getArchiveDateFromDate parses a date in yyyy-mm-dd format and returns the Unix epoch at start of that day (UTC).
+func getArchiveDateFromDate(dateStr string) (int64, error) {
+	t, err := time.ParseInLocation(archiveDateFormat, dateStr, time.UTC)
+	if err != nil {
+		return 0, slackerror.New(slackerror.ErrInvalidArguments).
+			WithMessage("Invalid archive date: %q", dateStr).
+			WithRemediation("Use yyyy-mm-dd format (e.g., 2025-12-31)")
+	}
+	return t.Unix(), nil
+}
+
 // slugFromsandboxName derives a domain-safe slug from org name (lowercase, alphanumeric + hyphens).
 func slugFromsandboxName(name string) string {
 	var b []byte
@@ -195,15 +226,14 @@ func slugFromsandboxName(name string) string {
 	return string(b)
 }
 
-func printCreateSuccess(cmd *cobra.Command, clients *shared.ClientFactory, result types.CreateSandboxResult) {
+func printCreateSuccess(cmd *cobra.Command, clients *shared.ClientFactory, teamID, url string) {
 	ctx := cmd.Context()
 	clients.IO.PrintInfo(ctx, false, "\n%s", style.Sectionf(style.TextSection{
 		Emoji: "beach_with_umbrella",
 		Text:  " Sandbox Created",
 		Secondary: []string{
-			fmt.Sprintf("Team ID: %s", result.TeamID),
-			fmt.Sprintf("User ID: %s", result.UserID),
-			fmt.Sprintf("URL: %s", result.URL),
+			fmt.Sprintf("Team ID: %s", teamID),
+			fmt.Sprintf("URL: %s", url),
 		},
 	}))
 }