Modern Docker Management, Designed for Everyone
Go composecontainer-managementcontainersdockerdocker-composedocker-managementgoself-hostedsveltekittypescriptweb-ui
package environments
import (
"cmp"
"errors"
"fmt"
"net/http"
"sort"
"strconv"
"strings"
"charm.land/lipgloss/v2"
"github.com/getarcaneapp/arcane/types/v2/environment"
"github.com/getarcaneapp/arcane/types/v2/version"
"github.com/spf13/cobra"
"go.getarcane.app/kit/pkg"
"github.com/getarcaneapp/arcane/cli/v2/internal/cmdutil"
"github.com/getarcaneapp/arcane/cli/v2/internal/config"
"github.com/getarcaneapp/arcane/cli/v2/internal/output"
"github.com/getarcaneapp/arcane/cli/v2/internal/prompt"
"github.com/getarcaneapp/arcane/cli/v2/internal/types"
)
var (
statusOnlineStyle = lipgloss.NewStyle().Foreground(lipgloss.Color("#22c55e"))
statusOfflineStyle = lipgloss.NewStyle().Foreground(lipgloss.Color("#ef4444"))
statusMutedStyle = lipgloss.NewStyle().Foreground(lipgloss.Color("#94a3b8"))
enabledStyle = lipgloss.NewStyle().Foreground(lipgloss.Color("#6d28d9"))
)
// Command is the parent command for environment operations
func Command() *cobra.Command {
command := &cobra.Command{
Use: "environments",
Aliases: []string{"environment", "env", "e"},
Short: "Manage environments",
}
command.AddCommand(newListCmd())
command.AddCommand(newGetCmd())
command.AddCommand(newTestCmd())
command.AddCommand(newDeleteCmd())
command.AddCommand(newSwitchCmd())
command.AddCommand(newUpdateCmd())
command.AddCommand(newVersionCmd())
command.AddCommand(newCreateCmd())
return command
}
func newListCmd() *cobra.Command {
var opts struct {
limit int
start int
all bool
}
command := &cobra.Command{
Use: "list",
Aliases: []string{"ls"},
Short: "List environments",
Args: cobra.NoArgs,
SilenceUsage: true,
RunE: func(cmd *cobra.Command, args []string) error {
c, err := cmdutil.ClientFromCommand(cmd)
if err != nil {
return err
}
return cmdutil.RunList(cmd, c, cmdutil.ListSpec[environment.Environment]{
Resource: "environments",
Endpoint: types.Environments(),
Params: cmdutil.ListParams{Resource: "environments", Limit: opts.limit, FallbackDefault: 20, Start: opts.start, All: opts.all},
Headers: []string{"ID", "NAME", "API URL", "STATUS", "ENABLED"},
Row: func(env environment.Environment) []string {
return []string{
env.ID,
env.Name,
env.ApiUrl,
env.Status,
strconv.FormatBool(env.Enabled),
}
},
})
},
}
command.Flags().IntVarP(&opts.limit, "limit", "n", 20, "Number of environments to show")
command.Flags().IntVar(&opts.start, "start", 0, cmdutil.StartFlagUsage)
command.Flags().BoolVarP(&opts.all, "all", "a", false, cmdutil.AllFlagUsage)
return command
}
func newDeleteCmd() *cobra.Command {
var opts struct {
force bool
}
command := &cobra.Command{
Use: "delete <id>",
Aliases: []string{"rm", "remove"},
Short: "Delete environment",
Args: cobra.ExactArgs(1),
SilenceUsage: true,
RunE: func(cmd *cobra.Command, args []string) error {
c, err := cmdutil.ClientFromCommand(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 environment %s?", args[0]),
Path: types.Environment(args[0]),
FailureMessage: "failed to delete environment",
SuccessMessage: "Environment deleted successfully",
})
},
}
command.Flags().BoolVarP(&opts.force, "force", "f", false, "Force deletion without confirmation")
return command
}
func newGetCmd() *cobra.Command {
return &cobra.Command{
Use: "get <id>",
Short: "Get environment details",
Args: cobra.ExactArgs(1),
SilenceUsage: true,
RunE: func(cmd *cobra.Command, args []string) error {
c, err := cmdutil.ClientFromCommand(cmd)
if err != nil {
return err
}
return cmdutil.Run(cmd, c, cmdutil.Spec[environment.Environment]{
Method: http.MethodGet,
Path: types.Environment(args[0]),
FailureMessage: "failed to get environment",
Body: nil,
Render: func(data environment.Environment) error {
output.Header("Environment Details")
output.KeyValue("ID", data.ID)
output.KeyValue("Name", data.Name)
output.KeyValue("API URL", data.ApiUrl)
output.KeyValue("Status", data.Status)
output.KeyValue("Enabled", data.Enabled)
return nil
},
})
},
}
}
func newTestCmd() *cobra.Command {
return &cobra.Command{
Use: "test <id>",
Short: "Test environment connection",
Args: cobra.ExactArgs(1),
SilenceUsage: true,
RunE: func(cmd *cobra.Command, args []string) error {
c, err := cmdutil.ClientFromCommand(cmd)
if err != nil {
return err
}
return cmdutil.Run(cmd, c, cmdutil.Spec[environment.Test]{
Method: http.MethodPost,
Path: types.EnvironmentTest(args[0]),
FailureMessage: "failed to test environment",
Render: func(environment.Test) error {
output.Success("%s", "Environment connection test successful")
return nil
},
})
},
}
}
func newSwitchCmd() *cobra.Command {
return &cobra.Command{
Use: "switch",
Short: "Switch the default environment (interactive)",
Args: cobra.NoArgs,
SilenceUsage: true,
RunE: func(cmd *cobra.Command, args []string) error {
if !cmdutil.AllowPrompt(cmd) {
return errors.New("interactive terminal required; run `arcane config set environment <id>` instead")
}
cfg, err := config.Load()
if err != nil {
return fmt.Errorf("failed to load config: %w", err)
}
c, err := cmdutil.ClientFromCommand(cmd)
if err != nil {
return err
}
path := fmt.Sprintf("%s?limit=%d", types.Environments(), cmdutil.ShowAllLimit)
result, err := c.GetJSON[[]environment.Environment](cmd.Context(), path)
if err != nil {
return fmt.Errorf("failed to list environments: %w", err)
}
if len(result.Data) == 0 {
return errors.New("no environments available")
}
currentEnv := cmp.Or(strings.TrimSpace(cfg.DefaultEnvironment), "0")
envs := result.Data
sort.SliceStable(envs, func(i, j int) bool {
left := strings.ToLower(cmp.Or(strings.TrimSpace(envs[i].Name), envs[i].ID))
right := strings.ToLower(cmp.Or(strings.TrimSpace(envs[j].Name), envs[j].ID))
if left == right {
return envs[i].ID < envs[j].ID
}
return left < right
})
choice, err := prompt.Select("environment", environmentOptions(envs, currentEnv))
if err != nil {
return err
}
selected := envs[choice]
if selected.ID == currentEnv {
output.Info("Default environment already set to %s", selected.ID)
return nil
}
cfg.DefaultEnvironment = selected.ID
if saveErr := config.Save(cmd.Context(), cfg); saveErr != nil {
return fmt.Errorf("failed to save config: %w", saveErr)
}
output.Success("Default environment set to %s", selected.ID)
if strings.TrimSpace(selected.Name) != "" {
output.KeyValue("Name", selected.Name)
}
output.KeyValue("API URL", selected.ApiUrl)
return nil
},
}
}
func newUpdateCmd() *cobra.Command {
var opts struct {
name string
apiUrl string
enabled bool
disabled bool
}
command := &cobra.Command{
Use: "update <id>",
Short: "Update environment",
Args: cobra.ExactArgs(1),
SilenceUsage: true,
PreRunE: func(cmd *cobra.Command, _ []string) error {
// TODO(v3): drop the deprecated flag handling.
return cmdutil.ExclusiveFlags(cmd, "enabled", "disabled")
},
RunE: func(cmd *cobra.Command, args []string) error {
c, err := cmdutil.ClientFromCommand(cmd)
if err != nil {
return err
}
// TODO(v3): drop the deprecated flag handling.
enabled := cmd.Flags().Changed("enabled") && opts.enabled || cmd.Flags().Changed("disabled") && !opts.disabled
req := environment.Update{
Name: kit.Ternary(cmd.Flags().Changed("name"), &opts.name, nil),
ApiUrl: kit.Ternary(cmd.Flags().Changed("api-url"), &opts.apiUrl, nil),
// TODO(v3): drop the deprecated flag handling.
Enabled: kit.Ternary(cmd.Flags().Changed("enabled") || cmd.Flags().Changed("disabled"), &enabled, nil),
}
return cmdutil.Run(cmd, c, cmdutil.Spec[environment.Environment]{
Method: http.MethodPut,
Path: types.Environment(args[0]),
FailureMessage: "failed to update environment",
Body: req,
Render: func(data environment.Environment) error {
output.Success("Environment updated successfully")
output.KeyValue("ID", data.ID)
output.KeyValue("Name", data.Name)
output.KeyValue("API URL", data.ApiUrl)
output.KeyValue("Enabled", data.Enabled)
return nil
},
})
},
}
command.Flags().StringVar(&opts.name, "name", "", "Environment name")
command.Flags().StringVar(&opts.apiUrl, "api-url", "", "API URL")
command.Flags().BoolVar(&opts.enabled, "enabled", false, "Enable environment")
command.Flags().BoolVar(&opts.disabled, "disabled", false, "Disable environment")
// TODO(v3): remove the deprecated --disabled flag.
_ = command.Flags().MarkDeprecated("disabled", "use --enabled=false")
return command
}
func newCreateCmd() *cobra.Command {
var opts struct {
name string
apiUrl string
accessToken string
useApiKey bool
edge bool
disabled bool
enabled bool
}
command := &cobra.Command{
Use: "create",
Short: "Create environment",
Args: cobra.NoArgs,
SilenceUsage: true,
PreRunE: func(cmd *cobra.Command, _ []string) error {
// TODO(v3): drop the deprecated flag handling.
return cmdutil.ExclusiveFlags(cmd, "enabled", "disabled")
},
RunE: func(cmd *cobra.Command, args []string) error {
c, err := cmdutil.ClientFromCommand(cmd)
if err != nil {
return err
}
req := environment.Create{
ApiUrl: opts.apiUrl,
Name: kit.Ternary(cmd.Flags().Changed("name"), &opts.name, nil),
AccessToken: kit.Ternary(cmd.Flags().Changed("access-token"), &opts.accessToken, nil),
UseApiKey: kit.Ternary(cmd.Flags().Changed("use-api-key"), &opts.useApiKey, nil),
IsEdge: kit.Ternary(cmd.Flags().Changed("edge"), &opts.edge, nil),
// TODO(v3): drop the deprecated flag handling.
Enabled: kit.Ternary(cmd.Flags().Changed("enabled") || cmd.Flags().Changed("disabled"), new(opts.enabled && !opts.disabled), nil),
}
return cmdutil.Run(cmd, c, cmdutil.Spec[environment.Environment]{
Method: http.MethodPost,
Path: types.Environments(),
FailureMessage: "failed to create environment",
Body: req,
Render: func(data environment.Environment) error {
output.Success("Environment created successfully")
output.KeyValue("ID", data.ID)
output.KeyValue("Name", data.Name)
output.KeyValue("API URL", data.ApiUrl)
output.KeyValue("Enabled", data.Enabled)
if data.ApiKey != nil && *data.ApiKey != "" {
output.Warning("Pairing API key (shown only once) — store it now:")
output.KeyValue("API Key", *data.ApiKey)
}
return nil
},
})
},
}
command.Flags().StringVar(&opts.apiUrl, "api-url", "", "API URL of the environment (required)")
command.Flags().StringVar(&opts.name, "name", "", "Environment name")
command.Flags().StringVar(&opts.accessToken, "access-token", "", "Access token for legacy pairing")
command.Flags().BoolVar(&opts.useApiKey, "use-api-key", false, "Pair using a generated API key (shown once)")
command.Flags().BoolVar(&opts.edge, "edge", false, "Create as an edge environment")
command.Flags().BoolVar(&opts.enabled, "enabled", true, "Enable environment")
command.Flags().BoolVar(&opts.disabled, "disabled", false, "Create environment in disabled state")
// TODO(v3): remove the deprecated --disabled flag.
_ = command.Flags().MarkDeprecated("disabled", "use --enabled=false")
_ = command.MarkFlagRequired("api-url")
return command
}
func newVersionCmd() *cobra.Command {
return &cobra.Command{
Use: "version <id>",
Short: "Get environment version",
Args: cobra.ExactArgs(1),
SilenceUsage: true,
RunE: func(cmd *cobra.Command, args []string) error {
c, err := cmdutil.ClientFromCommand(cmd)
if err != nil {
return err
}
return cmdutil.Run(cmd, c, cmdutil.Spec[version.Info]{
Method: http.MethodGet,
Path: types.EnvironmentVersion(args[0]),
FailureMessage: "failed to get environment version",
Render: func(data version.Info) error {
output.Header("Environment Version")
output.KeyValue("Version", data.DisplayVersion)
output.KeyValue("Full Version", data.CurrentVersion)
output.KeyValue("Tag", data.CurrentTag)
output.KeyValue("Revision", data.ShortRevision)
output.KeyValue("Go Version", data.GoVersion)
output.KeyValue("Build Time", data.BuildTime)
output.KeyValue("Update Available", strconv.FormatBool(data.UpdateAvailable))
return nil
},
})
},
}
}
func environmentOptions(environments []environment.Environment, currentEnv string) []string {
options := make([]string, len(environments))
for i, env := range environments {
displayName := cmp.Or(strings.TrimSpace(env.Name), env.ID)
status := cmp.Or(strings.TrimSpace(env.Status), "unknown")
var statusLabel string
switch strings.ToLower(status) {
case "online":
statusLabel = statusOnlineStyle.Render(status)
case "offline":
statusLabel = statusOfflineStyle.Render(status)
default:
statusLabel = statusMutedStyle.Render(status)
}
enabledLabel := statusMutedStyle.Render("disabled")
if env.Enabled {
enabledLabel = enabledStyle.Render("enabled")
}
marker := " "
if env.ID == currentEnv {
marker = "* "
}
options[i] = fmt.Sprintf("%s%s (id: %s, %s, %s)", marker, displayName, env.ID, statusLabel, enabledLabel)
}
return options
}