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

@@ -15,14 +15,12 @@
 package sandbox
 
 import (
-	"encoding/json"
 	"fmt"
 	"strconv"
 	"strings"
 	"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"
@@ -36,25 +34,21 @@ type createFlags struct {
 	owningOrgID string
 	template    string
 	eventCode   string
-	ttl         string
-	autoLogin   bool
-	output      string
-	token       string
+	archiveTTL  string // TTL duration, e.g. 1d, 2h
+	archiveDate string // explicit date yyyy-mm-dd
 }
 
 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-ttl 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,79 +62,80 @@ 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.locale, "locale", "", "Locale (eg. en-us, languageCode-countryCode)")
 	cmd.Flags().StringVar(&createCmdFlags.template, "template", "", "Template ID for pre-defined data to preload")
 	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.output, "output", "text", "Output format: json, text")
-	cmd.Flags().StringVar(&createCmdFlags.token, "token", "", "Service account token for CI/CD authentication")
+	cmd.Flags().StringVar(&createCmdFlags.archiveTTL, "archive-ttl", "", "Time-to-live duration; sandbox will be archived at end of day after this period (e.g., 2h, 1d, 7d)")
+	cmd.Flags().StringVar(&createCmdFlags.archiveDate, "archive-date", "", "Explicit archive date in yyyy-mm-dd format. Cannot be used with --archive")
 
-	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("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
 	}
 
 	domain := createCmdFlags.domain
 	if domain == "" {
-		domain = slugFromsandboxName(createCmdFlags.name)
+		domain = domainFromName(createCmdFlags.name)
 	}
 
-	archiveDate, err := ttlToArchiveDate(createCmdFlags.ttl)
-	if err != nil {
-		return err
+	if createCmdFlags.archiveTTL != "" && createCmdFlags.archiveDate != "" {
+		return slackerror.New(slackerror.ErrInvalidArguments).
+			WithMessage("Cannot use both --archive-ttl and --archive-date").
+			WithRemediation("Use only one: --archive-ttl for TTL (e.g., 3d) or --archive-date for a specific date (yyyy-mm-dd)")
+	}
+
+	archiveEpochDatetime := int64(0)
+	if createCmdFlags.archiveTTL != "" {
+		archiveEpochDatetime, err = getEpochFromTTL(createCmdFlags.archiveTTL)
+		if err != nil {
+			return err
+		}
+	} else if createCmdFlags.archiveDate != "" {
+		archiveEpochDatetime, err = getEpochFromDate(createCmdFlags.archiveDate)
+		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,
 		createCmdFlags.locale,
 		createCmdFlags.owningOrgID,
 		createCmdFlags.template,
 		createCmdFlags.eventCode,
-		archiveDate,
+		archiveEpochDatetime,
 	)
 	if err != nil {
 		return err
 	}
 
-	switch createCmdFlags.output {
-	case "json":
-		encoder := json.NewEncoder(clients.IO.WriteOut())
-		encoder.SetIndent("", "  ")
-		if err := encoder.Encode(result); 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
-	}
+// getEpochFromTTL 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 getEpochFromTTL(ttl string) (int64, error) {
 	var d time.Duration
 	if strings.HasSuffix(strings.ToLower(ttl), "d") {
 		numStr := strings.TrimSuffix(strings.ToLower(ttl), "d")
@@ -160,16 +155,23 @@ func ttlToArchiveDate(ttl string) (int64, error) {
 				WithRemediation("Use a duration like 2h, 1d, or 7d")
 		}
 	}
-	if d > maxTTL {
+	return time.Now().Add(d).Unix(), nil
+}
+
+// getEpochFromDate parses a date in yyyy-mm-dd format and returns the Unix epoch at start of that day (UTC).
+func getEpochFromDate(dateStr string) (int64, error) {
+	dateFormat := "2006-01-02"
+	t, err := time.ParseInLocation(dateFormat, dateStr, time.UTC)
+	if err != nil {
 		return 0, slackerror.New(slackerror.ErrInvalidArguments).
-			WithMessage("TTL cannot exceed 6 months").
-			WithRemediation("Use a shorter duration (e.g., 2h, 1d, 7d)")
+			WithMessage("Invalid archive date: %q", dateStr).
+			WithRemediation("Use yyyy-mm-dd format (e.g., 2025-12-31)")
 	}
-	return time.Now().Add(d).Unix(), nil
+	return t.Unix(), nil
 }
 
-// slugFromsandboxName derives a domain-safe slug from org name (lowercase, alphanumeric + hyphens).
-func slugFromsandboxName(name string) string {
+// domainFromName derives domain-safe text from the name of the sandbox (lowercase, alphanumeric + hyphens).
+func domainFromName(name string) string {
 	var b []byte
 	for _, r := range name {
 		if (r >= 'a' && r <= 'z') || (r >= '0' && r <= '9') {
@@ -195,15 +197,15 @@ 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),
 		},
 	}))
+	clients.IO.PrintInfo(ctx, false, "Manage this sandbox from the CLI or visit\n%s", style.Secondary("https://api.slack.com/developer-program/sandboxes"))
 }