Skip to content

Modern Docker Management, Designed for Everyone

feat(cli): add commands for latest server features and adopt hyphen-free command naming

Kyle Mendelld84511b8d67b
diff --git a/.github/.golangci.yml b/.github/.golangci.yml
index 5cf3b7a46..5f4fba5e4 100644
--- a/.github/.golangci.yml
+++ b/.github/.golangci.yml
@@ -124,6 +124,10 @@ linters:
- linters:
- forbidigo
path: cli/
+ # Endpoint path builders are intentional one-line functions.
+ - linters:
+ - shimbad
+ path: internal/types/endpoints\.go
paths:
- '.*\.pb\.go$'
- third_party$
diff --git a/cli/internal/client/client.go b/cli/internal/client/client.go
index edd26c723..45e8edafe 100644
--- a/cli/internal/client/client.go
+++ b/cli/internal/client/client.go
@@ -476,7 +476,7 @@ func (c *Client) refreshAccessToken(ctx context.Context) error {
if c.baseURLParsed == nil {
return errors.New("invalid base URL")
}
- refreshURL := c.baseURLParsed.ResolveReference(&url.URL{Path: types.Endpoints.AuthRefresh()}).String()
+ refreshURL := c.baseURLParsed.ResolveReference(&url.URL{Path: types.AuthRefresh()}).String()
logger.GetLogger().Debug("Sending token refresh request", "url", refreshURL)
req, err := http.NewRequestWithContext(ctx, http.MethodPost, refreshURL, bytes.NewReader(bodyBytes))
diff --git a/cli/internal/cmdutil/upload.go b/cli/internal/cmdutil/upload.go
new file mode 100644
index 000000000..8563178f3
--- /dev/null
+++ b/cli/internal/cmdutil/upload.go
@@ -0,0 +1,112 @@
+package cmdutil
+
+import (
+ "bytes"
+ "context"
+ "io"
+ "net/http"
+ "os"
+ "path/filepath"
+ "strings"
+
+ "emperror.dev/errors"
+
+ "github.com/getarcaneapp/arcane/cli/v2/internal/client"
+ "github.com/getarcaneapp/arcane/cli/v2/internal/logger"
+ "github.com/getarcaneapp/arcane/cli/v2/internal/output"
+ "github.com/getarcaneapp/arcane/cli/v2/internal/types"
+ uploadtypes "github.com/getarcaneapp/arcane/types/v2/upload"
+)
+
+const uploadChunkAttempts = 3
+
+// UploadFileInChunks streams a local file to the server through a chunked
+// upload session of the given kind and returns the completed session ID. The
+// file is sent as independently retried chunks so reverse-proxy body limits
+// never see the full size. On failure the session is deleted server-side.
+// When showProgress is true a progress bar is rendered.
+func UploadFileInChunks(ctx context.Context, c *client.Client, kind, filePath string, showProgress bool) (string, error) {
+ log := logger.GetLogger()
+
+ file, err := os.Open(filePath)
+ if err != nil {
+ return "", errors.WrapIf(err, "failed to open file")
+ }
+ defer func() { _ = file.Close() }()
+ fileInfo, err := file.Stat()
+ if err != nil {
+ return "", errors.WrapIf(err, "failed to stat file")
+ }
+
+ var created struct {
+ Success bool `json:"success"`
+ Data uploadtypes.Session `json:"data"`
+ }
+ if err := c.DoJSON(ctx, http.MethodPost, types.UploadSessions(c.EnvID(), kind), uploadtypes.CreateSessionRequest{
+ Filename: filepath.Base(filePath),
+ Size: fileInfo.Size(),
+ }, &created); err != nil {
+ return "", errors.WrapIf(err, "failed to create upload session")
+ }
+ session := created.Data
+
+ log.Debugf("Uploading %s as %d chunks of %d bytes (session %s)", filePath, session.TotalChunks, session.ChunkSize, session.ID)
+
+ var progressUI *output.Progress
+ if showProgress {
+ progressUI = output.StartProgress("Uploading", fileInfo.Size())
+ defer progressUI.Stop()
+ }
+
+ deleteSession := func() {
+ if resp, deleteErr := c.Delete(context.WithoutCancel(ctx), types.UploadSession(c.EnvID(), kind, session.ID)); deleteErr == nil {
+ _ = resp.Body.Close()
+ }
+ }
+
+ buf := make([]byte, session.ChunkSize)
+ for index := range session.TotalChunks {
+ expected := session.ChunkSize
+ if index == session.TotalChunks-1 {
+ expected = session.Size - int64(index)*session.ChunkSize
+ }
+ if _, err := io.ReadFull(file, buf[:expected]); err != nil {
+ deleteSession()
+ return "", errors.WrapIf(err, "failed to read file")
+ }
+
+ chunkPath := types.UploadSessionChunk(c.EnvID(), kind, session.ID, index)
+ for attempt := 1; ; attempt++ {
+ resp, chunkErr := c.RequestRaw(ctx, http.MethodPut, chunkPath, bytes.NewReader(buf[:expected]), map[string]string{"Content-Type": "application/octet-stream"})
+ if chunkErr == nil {
+ ok := resp.StatusCode >= 200 && resp.StatusCode < 300
+ if !ok {
+ errorBody, _ := io.ReadAll(io.LimitReader(resp.Body, 4096))
+ chunkErr = errors.Errorf("chunk %d failed (status %d): %s", index, resp.StatusCode, strings.TrimSpace(string(errorBody)))
+ }
+ _ = resp.Body.Close()
+ if ok {
+ break
+ }
+ }
+ if attempt >= uploadChunkAttempts {
+ deleteSession()
+ return "", errors.WrapIf(chunkErr, "failed to upload file")
+ }
+ log.Debugf("Retrying chunk %d after error: %v", index, chunkErr)
+ }
+ if progressUI != nil {
+ progressUI.Add(expected)
+ }
+ }
+
+ return session.ID, nil
+}
+
+// AbortUploadSession deletes a chunked upload session, ignoring errors. Use it
+// when the consume step after a completed upload fails.
+func AbortUploadSession(ctx context.Context, c *client.Client, kind, sessionID string) {
+ if resp, err := c.Delete(context.WithoutCancel(ctx), types.UploadSession(c.EnvID(), kind, sessionID)); err == nil {
+ _ = resp.Body.Close()
+ }
+}
diff --git a/cli/internal/integrationtest/action_error_handling_test.go b/cli/internal/integrationtest/action_error_handling_test.go
index 30aedbd5b..3475be653 100644
--- a/cli/internal/integrationtest/action_error_handling_test.go
+++ b/cli/internal/integrationtest/action_error_handling_test.go
@@ -66,7 +66,7 @@ func TestSystemContainersStartAllSurfacesServerError(t *testing.T) {
configPath := writeCLIIntegrationConfigInternal(t, srv.URL)
outBuf, errOut, err := executeCLIIntegrationCommandInternal(
t,
- []string{"--config", configPath, "system", "containers-start-all"},
+ []string{"--config", configPath, "system", "containers", "start"},
)
require.Error(t, err,
diff --git a/cli/internal/integrationtest/command_naming_test.go b/cli/internal/integrationtest/command_naming_test.go
new file mode 100644
index 000000000..ed02bdb6a
--- /dev/null
+++ b/cli/internal/integrationtest/command_naming_test.go
@@ -0,0 +1,31 @@
+package integrationtest
+
+import (
+ "strings"
+ "testing"
+
+ clipkg "github.com/getarcaneapp/arcane/cli/v2/pkg"
+ "github.com/spf13/cobra"
+)
+
+// Command names must never contain hyphens; multi-word actions are flags or
+// nested subcommands instead. Hidden commands are exempt (back-compat
+// spellings of renamed commands), as is self-update — the one allowed
+// hyphenated name.
+func TestNoHyphenatedCommandNames(t *testing.T) {
+ var walk func(cmd *cobra.Command, path string)
+ walk = func(cmd *cobra.Command, path string) {
+ for _, child := range cmd.Commands() {
+ if child.Hidden || child.Name() == "self-update" {
+ continue
+ }
+ childPath := path + " " + child.Name()
+ if strings.Contains(child.Name(), "-") {
+ t.Errorf("command %q has a hyphenated name; use a flag or nested subcommand instead", childPath)
+ }
+ walk(child, childPath)
+ }
+ }
+ root := clipkg.RootCommand()
+ walk(root, root.Name())
+}
diff --git a/cli/internal/integrationtest/pagination_test.go b/cli/internal/integrationtest/pagination_test.go
index b1ee60e86..5c0780878 100644
--- a/cli/internal/integrationtest/pagination_test.go
+++ b/cli/internal/integrationtest/pagination_test.go
@@ -257,7 +257,7 @@ func TestAdminEventsListEnvSendsLimitAndStart(t *testing.T) {
configPath := writeCLIIntegrationConfigInternal(t, srv.URL)
_, errOut, err := executeCLIIntegrationCommandInternal(
t,
- []string{"--config", configPath, "admin", "events", "list-env", "--json", "--limit", "3", "--start", "6"},
+ []string{"--config", configPath, "admin", "events", "list", "--environment", "--json", "--limit", "3", "--start", "6"},
)
require.NoError(t, err,
diff --git a/cli/internal/integrationtest/updates_commands_test.go b/cli/internal/integrationtest/updates_commands_test.go
index d8cb11567..1a4035a7e 100644
--- a/cli/internal/integrationtest/updates_commands_test.go
+++ b/cli/internal/integrationtest/updates_commands_test.go
@@ -290,7 +290,7 @@ func TestImagesUpdatesCheckRequiresImageRef(t *testing.T) {
require.Error(t, err,
"expected missing image reference to fail, got output %q", outBuf)
- require.False(t, !strings.Contains(err.Error(), "1 arg") || !strings.Contains(err.Error(), "received 0"),
+ require.Contains(t, err.Error(), "at least one image reference",
"unexpected argument error: %v", err)
}
diff --git a/cli/internal/types/endpoints.go b/cli/internal/types/endpoints.go
index 45013d6c1..c96a91a7c 100644
--- a/cli/internal/types/endpoints.go
+++ b/cli/internal/types/endpoints.go
@@ -1,3 +1,9 @@
+// Package types provides the Arcane API endpoint path builders and CLI
+// configuration types.
+//
+// Each endpoint is a plain function that returns the request path, escaping
+// every caller-supplied segment so resource names with special characters
+// cannot alter the route.
package types
import (
@@ -5,753 +11,479 @@ import (
"net/url"
)
-// ArcaneApiEndpoints holds the API endpoint path templates for the Arcane API.
-// Endpoint paths may contain format specifiers (e.g., %s) for environment IDs or resource IDs.
-type ArcaneApiEndpoints struct {
- // Version
- VersionEndpoint string
- AppVersionEndpoint string
-
- // Authentication
- AuthLogoutEndpoint string
- AuthMeEndpoint string
- AuthPasswordEndpoint string
- AuthRefreshEndpoint string
- AuthFederatedEndpoint string
-
- // OIDC
- OIDCDeviceCodeEndpoint string
- OIDCDeviceTokenEndpoint string
- OIDCStatusEndpoint string
-
- // API Keys
- ApiKeysEndpoint string
- ApiKeyEndpoint string
-
- // Users
- UsersEndpoint string
- UserEndpoint string
- UserRoleAssignmentsEndpoint string
-
- // Roles (RBAC)
- RolesEndpoint string
- RoleEndpoint string
- RolesAvailablePermissionsEndpoint string
-
- // OIDC role mappings
- OidcRoleMappingsEndpoint string
- OidcRoleMappingEndpoint string
-
- // Environments
- EnvironmentsEndpoint string
- EnvironmentEndpoint string
- EnvironmentTestEndpoint string
- EnvironmentVersionEndpoint string
-
- // Containers
- ContainersEndpoint string
- ContainerEndpoint string
- ContainerStartEndpoint string
- ContainerStopEndpoint string
- ContainerRestartEndpoint string
- ContainerUpdateEndpoint string
- ContainerRedeployEndpoint string
- ContainersCountsEndpoint string
-
- // Images
- ImagesEndpoint string
- ImageEndpoint string
- ImagesPullEndpoint string
- ImagesPruneEndpoint string
- ImagesCountsEndpoint string
- ImagesUploadEndpoint string
-
- // Upload sessions
- UploadSessionsEndpoint string
- UploadSessionEndpoint string
- UploadSessionChunkEndpoint string
-
- // Image Updates
- ImageUpdatesCheckEndpoint string
- ImageUpdatesCheckAllEndpoint string
- ImageUpdatesCheckByIdEndpoint string
- ImageUpdatesSummaryEndpoint string
-
- // Networks
- NetworksEndpoint string
- NetworkEndpoint string
- NetworksCountsEndpoint string
- NetworksPruneEndpoint string
-
- // Volumes
- VolumesEndpoint string
- VolumeEndpoint string
- VolumesCountsEndpoint string
- VolumesPruneEndpoint string
- VolumesSizesEndpoint string
- VolumeUsageEndpoint string
-
- // Projects (Stacks)
- ProjectsEndpoint string
- ProjectEndpoint string
- ProjectsCountsEndpoint string
- ProjectDestroyEndpoint string
- ProjectUpEndpoint string
- ProjectDownEndpoint string
- ProjectRestartEndpoint string
- ProjectRedeployEndpoint string
- ProjectPullEndpoint string
- ProjectWorkspaceEndpoint string
-
- // System
- SystemPruneEndpoint string
- SystemDockerInfoEndpoint string
- SystemContainersStartAllEndpoint string
- SystemContainersStopAllEndpoint string
- SystemStartStoppedEndpoint string
- SystemConvertEndpoint string
- SystemUpgradeEndpoint string
- SystemUpgradeCheckEndpoint string
-
- // Updater
- UpdaterStatusEndpoint string
- UpdaterRunEndpoint string
- UpdaterHistoryEndpoint string
-
- // Job Schedules
- JobSchedulesEndpoint string
-
- // Settings
- SettingsEndpoint string
- SettingsPublicEndpoint string
-
- // Notifications
- NotificationsSettingsEndpoint string
- NotificationSettingsProviderEndpoint string
- NotificationsTestProviderEndpoint string
-
- // Container Registries
- ContainerRegistriesEndpoint string
- ContainerRegistryEndpoint string
- ContainerRegistryTestEndpoint string
-
- // Events
- EventsEndpoint string
- EventEndpoint string
- EventsEnvironmentEndpoint string
-
- // Templates
- TemplatesEndpoint string
- TemplateEndpoint string
- TemplatesAllEndpoint string
- TemplatesDefaultEndpoint string
- TemplatesRegistriesEndpoint string
- TemplateRegistryEndpoint string
- VariableEndpoint string
- TemplatesVariablesEndpoint string
- TemplateContentEndpoint string
- TemplateDownloadEndpoint string
- TemplateFetchEndpoint string
-
- // Dashboard
- DashboardEndpoint string
-
- // Assets
- AppImagesFaviconEndpoint string
- AppImagesLogoEndpoint string
- AppImagesProfileEndpoint string
-
- // Customization
- CustomizeCategoriesEndpoint string
- CustomizeSearchEndpoint string
-
- // GitOps Syncs
- GitOpsSyncsEndpoint string
- GitOpsSyncEndpoint string
- GitOpsSyncStatusEndpoint string
- GitOpsSyncTriggerEndpoint string
- GitOpsSyncFilesEndpoint string
- GitOpsSyncsImportEndpoint string
-
- // Git Repositories
- GitRepositoriesEndpoint string
- GitRepositoryEndpoint string
- GitRepositoryTestEndpoint string
- GitRepositoryBranchesEndpoint string
- GitRepositoryFilesEndpoint string
-}
-
-// Endpoints contains the defined API endpoints
-var Endpoints = ArcaneApiEndpoints{ //nolint:gosec // static endpoint paths; auth-related names are not credentials
- // Version
- VersionEndpoint: "/api/version",
- AppVersionEndpoint: "/api/app-version",
-
- // Authentication
- AuthLogoutEndpoint: "/api/auth/logout",
- AuthMeEndpoint: "/api/auth/me",
- AuthPasswordEndpoint: "/api/auth/password",
- AuthRefreshEndpoint: "/api/auth/refresh",
- AuthFederatedEndpoint: "/api/auth/federated/token",
-
- // OIDC
- OIDCDeviceCodeEndpoint: "/api/oidc/device/code",
- OIDCDeviceTokenEndpoint: "/api/oidc/device/token",
- OIDCStatusEndpoint: "/api/oidc/status",
-
- // API Keys
- ApiKeysEndpoint: "/api/api-keys",
- ApiKeyEndpoint: "/api/api-keys/%s",
-
- // Users
- UsersEndpoint: "/api/users",
- UserEndpoint: "/api/users/%s",
- UserRoleAssignmentsEndpoint: "/api/users/%s/role-assignments",
-
- // Roles (RBAC)
- RolesEndpoint: "/api/roles",
- RoleEndpoint: "/api/roles/%s",
- RolesAvailablePermissionsEndpoint: "/api/roles/available-permissions",
-
- // OIDC role mappings
- OidcRoleMappingsEndpoint: "/api/oidc/role-mappings",
- OidcRoleMappingEndpoint: "/api/oidc/role-mappings/%s",
-
- // Environments
- EnvironmentsEndpoint: "/api/environments",
- EnvironmentEndpoint: "/api/environments/%s",
- EnvironmentTestEndpoint: "/api/environments/%s/test",
- EnvironmentVersionEndpoint: "/api/environments/%s/version",
-
- // Containers
- ContainersEndpoint: "/api/environments/%s/containers",
- ContainerEndpoint: "/api/environments/%s/containers/%s",
- ContainerStartEndpoint: "/api/environments/%s/containers/%s/start",
- ContainerStopEndpoint: "/api/environments/%s/containers/%s/stop",
- ContainerRestartEndpoint: "/api/environments/%s/containers/%s/restart",
- ContainerUpdateEndpoint: "/api/environments/%s/containers/%s/update",
- ContainerRedeployEndpoint: "/api/environments/%s/containers/%s/redeploy",
- ContainersCountsEndpoint: "/api/environments/%s/containers/counts",
-
- // Images
- ImagesEndpoint: "/api/environments/%s/images",
- ImageEndpoint: "/api/environments/%s/images/%s",
- ImagesPullEndpoint: "/api/environments/%s/images/pull",
- ImagesPruneEndpoint: "/api/environments/%s/images/prune",
- ImagesCountsEndpoint: "/api/environments/%s/images/counts",
- ImagesUploadEndpoint: "/api/environments/%s/images/upload",
-
- // Upload sessions
- UploadSessionsEndpoint: "/api/environments/%s/uploads/%s",
- UploadSessionEndpoint: "/api/environments/%s/uploads/%s/%s",
- UploadSessionChunkEndpoint: "/api/environments/%s/uploads/%s/%s/chunks/%d",
-
- // Image Updates
- ImageUpdatesCheckEndpoint: "/api/environments/%s/image-updates/check",
- ImageUpdatesCheckAllEndpoint: "/api/environments/%s/image-updates/check-all",
- ImageUpdatesCheckByIdEndpoint: "/api/environments/%s/image-updates/check/%s",
- ImageUpdatesSummaryEndpoint: "/api/environments/%s/image-updates/summary",
-
- // Networks
- NetworksEndpoint: "/api/environments/%s/networks",
- NetworkEndpoint: "/api/environments/%s/networks/%s",
- NetworksCountsEndpoint: "/api/environments/%s/networks/counts",
- NetworksPruneEndpoint: "/api/environments/%s/networks/prune",
-
- // Volumes
- VolumesEndpoint: "/api/environments/%s/volumes",
- VolumeEndpoint: "/api/environments/%s/volumes/%s",
- VolumesCountsEndpoint: "/api/environments/%s/volumes/counts",
- VolumesPruneEndpoint: "/api/environments/%s/volumes/prune",
- VolumesSizesEndpoint: "/api/environments/%s/volumes/sizes",
- VolumeUsageEndpoint: "/api/environments/%s/volumes/%s/usage",
-
- // Projects (Stacks)
- ProjectsEndpoint: "/api/environments/%s/projects",
- ProjectEndpoint: "/api/environments/%s/projects/%s",
- ProjectsCountsEndpoint: "/api/environments/%s/projects/counts",
- ProjectDestroyEndpoint: "/api/environments/%s/projects/%s/destroy",
- ProjectUpEndpoint: "/api/environments/%s/projects/%s/up",
- ProjectDownEndpoint: "/api/environments/%s/projects/%s/down",
- ProjectRestartEndpoint: "/api/environments/%s/projects/%s/restart",
- ProjectRedeployEndpoint: "/api/environments/%s/projects/%s/redeploy",
- ProjectPullEndpoint: "/api/environments/%s/projects/%s/pull",
- ProjectWorkspaceEndpoint: "/api/environments/%s/projects/%s/workspace",
-
- // System
- SystemPruneEndpoint: "/api/environments/%s/system/prune",
- SystemDockerInfoEndpoint: "/api/environments/%s/system/docker/info",
- SystemContainersStartAllEndpoint: "/api/environments/%s/system/containers/start-all",
- SystemContainersStopAllEndpoint: "/api/environments/%s/system/containers/stop-all",
- SystemStartStoppedEndpoint: "/api/environments/%s/system/containers/start-stopped",
- SystemConvertEndpoint: "/api/environments/%s/system/convert",
- SystemUpgradeEndpoint: "/api/environments/%s/system/upgrade",
- SystemUpgradeCheckEndpoint: "/api/environments/%s/system/upgrade/check",
-
- // Updater
- UpdaterStatusEndpoint: "/api/environments/%s/updater/status",
- UpdaterRunEndpoint: "/api/environments/%s/updater/run",
- UpdaterHistoryEndpoint: "/api/environments/%s/updater/history",
-
- // Job Schedules
- JobSchedulesEndpoint: "/api/environments/%s/job-schedules",
-
- // Settings
- SettingsEndpoint: "/api/environments/%s/settings",
- SettingsPublicEndpoint: "/api/environments/%s/settings/public",
-
- // Notifications
- NotificationsSettingsEndpoint: "/api/environments/%s/notifications/settings",
- NotificationSettingsProviderEndpoint: "/api/environments/%s/notifications/settings/%s",
- NotificationsTestProviderEndpoint: "/api/environments/%s/notifications/test/%s",
-
- // Container Registries
- ContainerRegistriesEndpoint: "/api/container-registries",
- ContainerRegistryEndpoint: "/api/container-registries/%s",
- ContainerRegistryTestEndpoint: "/api/container-registries/%s/test",
-
- // Events
- EventsEndpoint: "/api/events",
- EventEndpoint: "/api/events/%s",
- EventsEnvironmentEndpoint: "/api/events/environment/%s",
-
- // Templates
- TemplatesEndpoint: "/api/templates",
- TemplateEndpoint: "/api/templates/%s",
- TemplatesAllEndpoint: "/api/templates/all",
- TemplatesDefaultEndpoint: "/api/templates/default",
- TemplatesRegistriesEndpoint: "/api/templates/registries",
- TemplateRegistryEndpoint: "/api/templates/registries/%s",
- TemplatesVariablesEndpoint: "/api/variables",
- VariableEndpoint: "/api/variables/%s",
- TemplateContentEndpoint: "/api/templates/%s/content",
- TemplateDownloadEndpoint: "/api/templates/%s/download",
- TemplateFetchEndpoint: "/api/templates/fetch",
-
- // Dashboard
- DashboardEndpoint: "/api/environments/%s/dashboard",
-
- // Assets
- AppImagesFaviconEndpoint: "/api/app-images/favicon",
- AppImagesLogoEndpoint: "/api/app-images/logo",
- AppImagesProfileEndpoint: "/api/app-images/profile",
-
- // Customization
- CustomizeCategoriesEndpoint: "/api/customize/categories",
- CustomizeSearchEndpoint: "/api/customize/search",
-
- // GitOps Syncs
- GitOpsSyncsEndpoint: "/api/environments/%s/gitops-syncs",
- GitOpsSyncEndpoint: "/api/environments/%s/gitops-syncs/%s",
- GitOpsSyncStatusEndpoint: "/api/environments/%s/gitops-syncs/%s/status",
- GitOpsSyncTriggerEndpoint: "/api/environments/%s/gitops-syncs/%s/sync",
- GitOpsSyncFilesEndpoint: "/api/environments/%s/gitops-syncs/%s/files",
- GitOpsSyncsImportEndpoint: "/api/environments/%s/gitops-syncs/import",
-
- // Git Repositories
- GitRepositoriesEndpoint: "/api/customize/git-repositories",
- GitRepositoryEndpoint: "/api/customize/git-repositories/%s",
- GitRepositoryTestEndpoint: "/api/customize/git-repositories/%s/test",
- GitRepositoryBranchesEndpoint: "/api/customize/git-repositories/%s/branches",
- GitRepositoryFilesEndpoint: "/api/customize/git-repositories/%s/files",
-}
+// pathf formats an API path, path-escaping every string argument.
+func pathf(format string, args ...any) string {
+ escaped := make([]any, len(args))
+ for i, arg := range args {
+ if s, ok := arg.(string); ok {
+ escaped[i] = url.PathEscape(s)
+ } else {
+ escaped[i] = arg
+ }
+ }
+ return fmt.Sprintf(format, escaped...)
+}
+
+// Version
+const (
+ VersionEndpoint = "/api/version"
+ AppVersionEndpoint = "/api/app-version"
+)
// Auth endpoints
-func (e ArcaneApiEndpoints) AuthLogout() string { return e.AuthLogoutEndpoint }
-func (e ArcaneApiEndpoints) AuthMe() string { return e.AuthMeEndpoint }
-func (e ArcaneApiEndpoints) AuthPassword() string { return e.AuthPasswordEndpoint }
-func (e ArcaneApiEndpoints) AuthRefresh() string { return e.AuthRefreshEndpoint }
-func (e ArcaneApiEndpoints) AuthFederated() string { return e.AuthFederatedEndpoint }
+func AuthLogout() string { return "/api/auth/logout" }
+func AuthMe() string { return "/api/auth/me" }
+func AuthPassword() string { return "/api/auth/password" }
+func AuthRefresh() string { return "/api/auth/refresh" }
+func AuthFederated() string { return "/api/auth/federated/token" }
// OIDC endpoints
-func (e ArcaneApiEndpoints) OIDCDeviceCode() string { return e.OIDCDeviceCodeEndpoint }
-func (e ArcaneApiEndpoints) OIDCDeviceToken() string { return e.OIDCDeviceTokenEndpoint }
-func (e ArcaneApiEndpoints) OIDCStatus() string { return e.OIDCStatusEndpoint }
+func OIDCDeviceCode() string { return "/api/oidc/device/code" }
+func OIDCDeviceToken() string { return "/api/oidc/device/token" }
+func OIDCStatus() string { return "/api/oidc/status" }
+
+// API key endpoints
+
+func ApiKeys() string { return "/api/api-keys" }
+func ApiKey(id string) string { return pathf("/api/api-keys/%s", id) }
-// API Key endpoints
+// Self-service API key endpoints
-func (e ArcaneApiEndpoints) ApiKeys() string { return e.ApiKeysEndpoint }
-func (e ArcaneApiEndpoints) ApiKey(id string) string { return fmt.Sprintf(e.ApiKeyEndpoint, id) }
+func AuthMeApiKeys() string { return "/api/auth/me/api-keys" }
+func AuthMeApiKey(id string) string { return pathf("/api/auth/me/api-keys/%s", id) }
// User endpoints
-func (e ArcaneApiEndpoints) Users() string { return e.UsersEndpoint }
-func (e ArcaneApiEndpoints) User(id string) string { return fmt.Sprintf(e.UserEndpoint, id) }
-func (e ArcaneApiEndpoints) UserRoleAssignments(userID string) string {
- return fmt.Sprintf(e.UserRoleAssignmentsEndpoint, userID)
+func Users() string { return "/api/users" }
+func User(id string) string { return pathf("/api/users/%s", id) }
+func UserRoleAssignments(userID string) string {
+ return pathf("/api/users/%s/role-assignments", userID)
}
// Role (RBAC) endpoints
-func (e ArcaneApiEndpoints) Roles() string { return e.RolesEndpoint }
-func (e ArcaneApiEndpoints) Role(id string) string { return fmt.Sprintf(e.RoleEndpoint, id) }
-func (e ArcaneApiEndpoints) RolesAvailablePermissions() string {
- return e.RolesAvailablePermissionsEndpoint
-}
+func Roles() string { return "/api/roles" }
+func Role(id string) string { return pathf("/api/roles/%s", id) }
+func RolesAvailablePermissions() string { return "/api/roles/available-permissions" }
// OIDC role mapping endpoints
-func (e ArcaneApiEndpoints) OidcRoleMappings() string { return e.OidcRoleMappingsEndpoint }
-func (e ArcaneApiEndpoints) OidcRoleMapping(id string) string {
- return fmt.Sprintf(e.OidcRoleMappingEndpoint, id)
-}
+func OidcRoleMappings() string { return "/api/oidc/role-mappings" }
+func OidcRoleMapping(id string) string { return pathf("/api/oidc/role-mappings/%s", id) }
-// Environment endpoints
+// Federated credential endpoints
-func (e ArcaneApiEndpoints) Environments() string { return e.EnvironmentsEndpoint }
+func FederatedCredentials() string { return "/api/federated-credentials" }
+func FederatedCredential(id string) string { return pathf("/api/federated-credentials/%s", id) }
-func (e ArcaneApiEndpoints) Environment(id string) string {
- return fmt.Sprintf(e.EnvironmentEndpoint, id)
-}
-
-func (e ArcaneApiEndpoints) EnvironmentTest(envID string) string {
- return fmt.Sprintf(e.EnvironmentTestEndpoint, envID)
-}
+// Environment endpoints
-func (e ArcaneApiEndpoints) EnvironmentVersion(envID string) string {
- return fmt.Sprintf(e.EnvironmentVersionEndpoint, envID)
+func Environments() string { return "/api/environments" }
+func Environment(id string) string { return pathf("/api/environments/%s", id) }
+func EnvironmentTest(envID string) string { return pathf("/api/environments/%s/test", envID) }
+func EnvironmentVersion(envID string) string {
+ return pathf("/api/environments/%s/version", envID)
}
// Container endpoints
-func (e ArcaneApiEndpoints) Containers(envID string) string {
- return fmt.Sprintf(e.ContainersEndpoint, envID)
+func Containers(envID string) string { return pathf("/api/environments/%s/containers", envID) }
+func Container(envID, containerID string) string {
+ return pathf("/api/environments/%s/containers/%s", envID, containerID)
}
-
-func (e ArcaneApiEndpoints) Container(envID, containerID string) string {
- return fmt.Sprintf(e.ContainerEndpoint, envID, containerID)
+func ContainerStart(envID, containerID string) string {
+ return pathf("/api/environments/%s/containers/%s/start", envID, containerID)
}
-
-func (e ArcaneApiEndpoints) ContainerStart(envID, containerID string) string {
- return fmt.Sprintf(e.ContainerStartEndpoint, envID, containerID)
+func ContainerStop(envID, containerID string) string {
+ return pathf("/api/environments/%s/containers/%s/stop", envID, containerID)
}
-
-func (e ArcaneApiEndpoints) ContainerStop(envID, containerID string) string {
- return fmt.Sprintf(e.ContainerStopEndpoint, envID, containerID)
+func ContainerRestart(envID, containerID string) string {
+ return pathf("/api/environments/%s/containers/%s/restart", envID, containerID)
}
-
-func (e ArcaneApiEndpoints) ContainerRestart(envID, containerID string) string {
- return fmt.Sprintf(e.ContainerRestartEndpoint, envID, containerID)
+func ContainerKill(envID, containerID string) string {
+ return pathf("/api/environments/%s/containers/%s/kill", envID, containerID)
}
-
-func (e ArcaneApiEndpoints) ContainerUpdate(envID, containerID string) string {
- return fmt.Sprintf(e.ContainerUpdateEndpoint, envID, containerID)
+func ContainerPause(envID, containerID string) string {
+ return pathf("/api/environments/%s/containers/%s/pause", envID, containerID)
}
-
-func (e ArcaneApiEndpoints) ContainerRedeploy(envID, containerID string) string {
- return fmt.Sprintf(e.ContainerRedeployEndpoint, envID, containerID)
+func ContainerUnpause(envID, containerID string) string {
+ return pathf("/api/environments/%s/containers/%s/unpause", envID, containerID)
}
-
-func (e ArcaneApiEndpoints) ContainersCounts(envID string) string {
- return fmt.Sprintf(e.ContainersCountsEndpoint, envID)
+func ContainerCommit(envID, containerID string) string {
+ return pathf("/api/environments/%s/containers/%s/commit", envID, containerID)
+}
+func ContainerUpdate(envID, containerID string) string {
+ return pathf("/api/environments/%s/containers/%s/update", envID, containerID)
+}
+func ContainerRedeploy(envID, containerID string) string {
+ return pathf("/api/environments/%s/containers/%s/redeploy", envID, containerID)
+}
+func ContainerEditConfig(envID, containerID string) string {
+ return pathf("/api/environments/%s/containers/%s/edit-config", envID, containerID)
+}
+func ContainerEdit(envID, containerID string) string {
+ return pathf("/api/environments/%s/containers/%s/edit", envID, containerID)
+}
+func ContainerAutoUpdate(envID, containerID string) string {
+ return pathf("/api/environments/%s/containers/%s/auto-update", envID, containerID)
+}
+func ContainersCounts(envID string) string {
+ return pathf("/api/environments/%s/containers/counts", envID)
}
// Image endpoints
-func (e ArcaneApiEndpoints) Images(envID string) string { return fmt.Sprintf(e.ImagesEndpoint, envID) }
-
-func (e ArcaneApiEndpoints) Image(envID, imageID string) string {
- return fmt.Sprintf(e.ImageEndpoint, envID, imageID)
+func Images(envID string) string { return pathf("/api/environments/%s/images", envID) }
+func Image(envID, imageID string) string {
+ return pathf("/api/environments/%s/images/%s", envID, imageID)
}
-
-func (e ArcaneApiEndpoints) ImagesPull(envID string) string {
- return fmt.Sprintf(e.ImagesPullEndpoint, envID)
+func ImagesPull(envID string) string { return pathf("/api/environments/%s/images/pull", envID) }
+func ImagesPrune(envID string) string { return pathf("/api/environments/%s/images/prune", envID) }
+func ImagesCounts(envID string) string { return pathf("/api/environments/%s/images/counts", envID) }
+func ImagesUpload(envID string) string { return pathf("/api/environments/%s/images/upload", envID) }
+func ImagesSearch(envID string) string { return pathf("/api/environments/%s/images/search", envID) }
+func ImageHistory(envID, name string) string {
+ return pathf("/api/environments/%s/images/%s/history", envID, name)
}
-
-func (e ArcaneApiEndpoints) ImagesPrune(envID string) string {
- return fmt.Sprintf(e.ImagesPruneEndpoint, envID)
+func ImageTag(envID, name string) string {
+ return pathf("/api/environments/%s/images/%s/tag", envID, name)
}
-
-func (e ArcaneApiEndpoints) ImagesCounts(envID string) string {
- return fmt.Sprintf(e.ImagesCountsEndpoint, envID)
+func ImageExport(envID, name string) string {
+ return pathf("/api/environments/%s/images/%s/export", envID, name)
}
-
-func (e ArcaneApiEndpoints) ImagesUpload(envID string) string {
- return fmt.Sprintf(e.ImagesUploadEndpoint, envID)
+func ImageAttestations(envID, name string) string {
+ return pathf("/api/environments/%s/images/%s/attestations", envID, name)
+}
+func ImagesBuild(envID string) string { return pathf("/api/environments/%s/images/build", envID) }
+func ImageBuilds(envID string) string { return pathf("/api/environments/%s/images/builds", envID) }
+func ImageBuild(envID, buildID string) string {
+ return pathf("/api/environments/%s/images/builds/%s", envID, buildID)
}
// Upload session endpoints
-func (e ArcaneApiEndpoints) UploadSessions(envID, kind string) string {
- return fmt.Sprintf(e.UploadSessionsEndpoint, envID, kind)
+func UploadSessions(envID, kind string) string {
+ return pathf("/api/environments/%s/uploads/%s", envID, kind)
}
-
-func (e ArcaneApiEndpoints) UploadSession(envID, kind, uploadID string) string {
- return fmt.Sprintf(e.UploadSessionEndpoint, envID, kind, uploadID)
+func UploadSession(envID, kind, uploadID string) string {
+ return pathf("/api/environments/%s/uploads/%s/%s", envID, kind, uploadID)
}
-
-func (e ArcaneApiEndpoints) UploadSessionChunk(envID, kind, uploadID string, index int) string {
- return fmt.Sprintf(e.UploadSessionChunkEndpoint, envID, kind, uploadID, index)
+func UploadSessionChunk(envID, kind, uploadID string, index int) string {
+ return pathf("/api/environments/%s/uploads/%s/%s/chunks/%d", envID, kind, uploadID, index)
}
-// Image Update endpoints
+// Image update endpoints
-func (e ArcaneApiEndpoints) ImageUpdatesCheck(envID, imageRef string) string {
+func ImageUpdatesCheck(envID, imageRef string) string {
query := url.Values{}
query.Set("imageRef", imageRef)
- return fmt.Sprintf(e.ImageUpdatesCheckEndpoint, envID) + "?" + query.Encode()
+ return pathf("/api/environments/%s/image-updates/check", envID) + "?" + query.Encode()
}
-
-func (e ArcaneApiEndpoints) ImageUpdatesCheckAll(envID string) string {
- return fmt.Sprintf(e.ImageUpdatesCheckAllEndpoint, envID)
+func ImageUpdatesCheckAll(envID string) string {
+ return pathf("/api/environments/%s/image-updates/check-all", envID)
}
-
-func (e ArcaneApiEndpoints) ImageUpdatesCheckById(envID, imageID string) string {
- return fmt.Sprintf(e.ImageUpdatesCheckByIdEndpoint, envID, imageID)
+func ImageUpdatesCheckById(envID, imageID string) string {
+ return pathf("/api/environments/%s/image-updates/check/%s", envID, imageID)
}
-
-func (e ArcaneApiEndpoints) ImageUpdatesSummary(envID string) string {
- return fmt.Sprintf(e.ImageUpdatesSummaryEndpoint, envID)
+func ImageUpdatesCheckBatch(envID string) string {
+ return pathf("/api/environments/%s/image-updates/check-batch", envID)
+}
+func ImageUpdatesSummary(envID string) string {
+ return pathf("/api/environments/%s/image-updates/summary", envID)
}
// Network endpoints
-func (e ArcaneApiEndpoints) Networks(envID string) string {
- return fmt.Sprintf(e.NetworksEndpoint, envID)
+func Networks(envID string) string { return pathf("/api/environments/%s/networks", envID) }
+func Network(envID, networkID string) string {
+ return pathf("/api/environments/%s/networks/%s", envID, networkID)
}
-
-func (e ArcaneApiEndpoints) Network(envID, networkID string) string {
- return fmt.Sprintf(e.NetworkEndpoint, envID, networkID)
+func NetworksCounts(envID string) string {
+ return pathf("/api/environments/%s/networks/counts", envID)
}
-
-func (e ArcaneApiEndpoints) NetworksCounts(envID string) string {
- return fmt.Sprintf(e.NetworksCountsEndpoint, envID)
+func NetworksPrune(envID string) string { return pathf("/api/environments/%s/networks/prune", envID) }
+func NetworksTopology(envID string) string {
+ return pathf("/api/environments/%s/networks/topology", envID)
}
-
-func (e ArcaneApiEndpoints) NetworksPrune(envID string) string {
- return fmt.Sprintf(e.NetworksPruneEndpoint, envID)
+func NetworkConnect(envID, networkID string) string {
+ return pathf("/api/environments/%s/networks/%s/connect", envID, networkID)
+}
+func NetworkDisconnect(envID, networkID string) string {
+ return pathf("/api/environments/%s/networks/%s/disconnect", envID, networkID)
}
// Volume endpoints
-func (e ArcaneApiEndpoints) Volumes(envID string) string {
- return fmt.Sprintf(e.VolumesEndpoint, envID)
+func Volumes(envID string) string { return pathf("/api/environments/%s/volumes", envID) }
+func Volume(envID, volumeName string) string {
+ return pathf("/api/environments/%s/volumes/%s", envID, volumeName)
}
-
-func (e ArcaneApiEndpoints) Volume(envID, volumeName string) string {
- return fmt.Sprintf(e.VolumeEndpoint, envID, volumeName)
+func VolumesCounts(envID string) string { return pathf("/api/environments/%s/volumes/counts", envID) }
+func VolumesPrune(envID string) string { return pathf("/api/environments/%s/volumes/prune", envID) }
+func VolumesSizes(envID string) string { return pathf("/api/environments/%s/volumes/sizes", envID) }
+func VolumeUsage(envID, volumeName string) string {
+ return pathf("/api/environments/%s/volumes/%s/usage", envID, volumeName)
}
-
-func (e ArcaneApiEndpoints) VolumesCounts(envID string) string {
- return fmt.Sprintf(e.VolumesCountsEndpoint, envID)
+func VolumeRename(envID, volumeName string) string {
+ return pathf("/api/environments/%s/volumes/%s/rename", envID, volumeName)
}
-func (e ArcaneApiEndpoints) VolumesPrune(envID string) string {
- return fmt.Sprintf(e.VolumesPruneEndpoint, envID)
-}
+// Volume backup endpoints
-func (e ArcaneApiEndpoints) VolumesSizes(envID string) string {
- return fmt.Sprintf(e.VolumesSizesEndpoint, envID)
+func VolumeBackupPolicy(envID, volumeName string) string {
+ return pathf("/api/environments/%s/volumes/%s/backup-policy", envID, volumeName)
+}
+func VolumeBackups(envID, volumeName string) string {
+ return pathf("/api/environments/%s/volumes/%s/backups", envID, volumeName)
+}
+func VolumeBackup(envID, backupID string) string {
+ return pathf("/api/environments/%s/volumes/backups/%s", envID, backupID)
+}
+func VolumeBackupRestore(envID, volumeName, backupID string) string {
+ return pathf("/api/environments/%s/volumes/%s/backups/%s/restore", envID, volumeName, backupID)
+}
+func VolumeBackupRestoreFiles(envID, volumeName, backupID string) string {
+ return pathf("/api/environments/%s/volumes/%s/backups/%s/restore-files", envID, volumeName, backupID)
+}
+func VolumeBackupUpload(envID, backupID string) string {
+ return pathf("/api/environments/%s/volumes/backups/%s/upload", envID, backupID)
+}
+func VolumeBackupDownload(envID, backupID string) string {
+ return pathf("/api/environments/%s/volumes/backups/%s/download", envID, backupID)
+}
+func VolumeBackupFiles(envID, backupID string) string {
+ return pathf("/api/environments/%s/volumes/backups/%s/files", envID, backupID)
+}
+func VolumeBackupUploadRestore(envID, volumeName string) string {
+ return pathf("/api/environments/%s/volumes/%s/backups/upload", envID, volumeName)
}
-func (e ArcaneApiEndpoints) VolumeUsage(envID, volumeName string) string {
- return fmt.Sprintf(e.VolumeUsageEndpoint, envID, volumeName)
+// Volume workspace endpoints
+
+func VolumeWorkspace(envID, volumeName string) string {
+ return pathf("/api/environments/%s/volumes/%s/workspace", envID, volumeName)
+}
+func VolumeWorkspaceFile(envID, volumeName string) string {
+ return pathf("/api/environments/%s/volumes/%s/workspace/file", envID, volumeName)
+}
+func VolumeWorkspaceFileDownload(envID, volumeName string) string {
+ return pathf("/api/environments/%s/volumes/%s/workspace/file/download", envID, volumeName)
}
// Project endpoints
-func (e ArcaneApiEndpoints) Projects(envID string) string {
- return fmt.Sprintf(e.ProjectsEndpoint, envID)
+func Projects(envID string) string { return pathf("/api/environments/%s/projects", envID) }
+func Project(envID, projectID string) string {
+ return pathf("/api/environments/%s/projects/%s", envID, projectID)
}
-
-func (e ArcaneApiEndpoints) Project(envID, projectID string) string {
- return fmt.Sprintf(e.ProjectEndpoint, envID, projectID)
+func ProjectsCounts(envID string) string {
+ return pathf("/api/environments/%s/projects/counts", envID)
}
-
-func (e ArcaneApiEndpoints) ProjectsCounts(envID string) string {
- return fmt.Sprintf(e.ProjectsCountsEndpoint, envID)
+func ProjectsTags(envID string) string { return pathf("/api/environments/%s/projects/tags", envID) }
+func ProjectTags(envID, projectID string) string {
+ return pathf("/api/environments/%s/projects/%s/tags", envID, projectID)
}
-
-func (e ArcaneApiEndpoints) ProjectDestroy(envID, projectID string) string {
- return fmt.Sprintf(e.ProjectDestroyEndpoint, envID, projectID)
+func ProjectDestroy(envID, projectID string) string {
+ return pathf("/api/environments/%s/projects/%s/destroy", envID, projectID)
}
-
-func (e ArcaneApiEndpoints) ProjectUp(envID, projectID string) string {
- return fmt.Sprintf(e.ProjectUpEndpoint, envID, projectID)
+func ProjectUp(envID, projectID string) string {
+ return pathf("/api/environments/%s/projects/%s/up", envID, projectID)
}
-
-func (e ArcaneApiEndpoints) ProjectDown(envID, projectID string) string {
- return fmt.Sprintf(e.ProjectDownEndpoint, envID, projectID)
+func ProjectDown(envID, projectID string) string {
+ return pathf("/api/environments/%s/projects/%s/down", envID, projectID)
}
-
-func (e ArcaneApiEndpoints) ProjectRestart(envID, projectID string) string {
- return fmt.Sprintf(e.ProjectRestartEndpoint, envID, projectID)
+func ProjectRestart(envID, projectID string) string {
+ return pathf("/api/environments/%s/projects/%s/restart", envID, projectID)
}
-
-func (e ArcaneApiEndpoints) ProjectRedeploy(envID, projectID string) string {
- return fmt.Sprintf(e.ProjectRedeployEndpoint, envID, projectID)
+func ProjectRedeploy(envID, projectID string) string {
+ return pathf("/api/environments/%s/projects/%s/redeploy", envID, projectID)
}
-
-func (e ArcaneApiEndpoints) ProjectPull(envID, projectID string) string {
- return fmt.Sprintf(e.ProjectPullEndpoint, envID, projectID)
+func ProjectPull(envID, projectID string) string {
+ return pathf("/api/environments/%s/projects/%s/pull", envID, projectID)
}
-
-func (e ArcaneApiEndpoints) ProjectWorkspace(envID, projectID string) string {
- return fmt.Sprintf(e.ProjectWorkspaceEndpoint, envID, projectID)
+func ProjectBuild(envID, projectID string) string {
+ return pathf("/api/environments/%s/projects/%s/build", envID, projectID)
+}
+func ProjectArchive(envID, projectID string) string {
+ return pathf("/api/environments/%s/projects/%s/archive", envID, projectID)
+}
+func ProjectUnarchive(envID, projectID string) string {
+ return pathf("/api/environments/%s/projects/%s/unarchive", envID, projectID)
+}
+func ProjectUpdateServices(envID, projectID string) string {
+ return pathf("/api/environments/%s/projects/%s/update-services", envID, projectID)
+}
+func ProjectWorkspace(envID, projectID string) string {
+ return pathf("/api/environments/%s/projects/%s/workspace", envID, projectID)
+}
+func ProjectWorkspaceFile(envID, projectID string) string {
+ return pathf("/api/environments/%s/projects/%s/workspace/file", envID, projectID)
+}
+func ProjectWorkspaceFileDownload(envID, projectID string) string {
+ return pathf("/api/environments/%s/projects/%s/workspace/file/download", envID, projectID)
}
// System endpoints
-func (e ArcaneApiEndpoints) SystemPrune(envID string) string {
- return fmt.Sprintf(e.SystemPruneEndpoint, envID)
+func SystemPrune(envID string) string { return pathf("/api/environments/%s/system/prune", envID) }
+func SystemDockerInfo(envID string) string {
+ return pathf("/api/environments/%s/system/docker/info", envID)
}
-
-func (e ArcaneApiEndpoints) SystemDockerInfo(envID string) string {
- return fmt.Sprintf(e.SystemDockerInfoEndpoint, envID)
+func SystemContainersStartAll(envID string) string {
+ return pathf("/api/environments/%s/system/containers/start-all", envID)
}
-
-func (e ArcaneApiEndpoints) SystemContainersStartAll(envID string) string {
- return fmt.Sprintf(e.SystemContainersStartAllEndpoint, envID)
+func SystemContainersStopAll(envID string) string {
+ return pathf("/api/environments/%s/system/containers/stop-all", envID)
}
-
-func (e ArcaneApiEndpoints) SystemContainersStopAll(envID string) string {
- return fmt.Sprintf(e.SystemContainersStopAllEndpoint, envID)
+func SystemStartStopped(envID string) string {
+ return pathf("/api/environments/%s/system/containers/start-stopped", envID)
}
-
-func (e ArcaneApiEndpoints) SystemStartStopped(envID string) string {
- return fmt.Sprintf(e.SystemStartStoppedEndpoint, envID)
+func SystemConvert(envID string) string { return pathf("/api/environments/%s/system/convert", envID) }
+func SystemUpgrade(envID string) string { return pathf("/api/environments/%s/system/upgrade", envID) }
+func SystemUpgradeCheck(envID string) string {
+ return pathf("/api/environments/%s/system/upgrade/check", envID)
}
-
-func (e ArcaneApiEndpoints) SystemConvert(envID string) string {
- return fmt.Sprintf(e.SystemConvertEndpoint, envID)
+func SystemUpgradeAll(envID string) string {
+ return pathf("/api/environments/%s/system/upgrade/all", envID)
}
-
-func (e ArcaneApiEndpoints) SystemUpgrade(envID string) string {
- return fmt.Sprintf(e.SystemUpgradeEndpoint, envID)
-}
-
-func (e ArcaneApiEndpoints) SystemUpgradeCheck(envID string) string {
- return fmt.Sprintf(e.SystemUpgradeCheckEndpoint, envID)
+func SystemUpgradeAllStatus(envID string) string {
+ return pathf("/api/environments/%s/system/upgrade/all/status", envID)
}
// Updater endpoints
-func (e ArcaneApiEndpoints) UpdaterStatus(envID string) string {
- return fmt.Sprintf(e.UpdaterStatusEndpoint, envID)
-}
-
-func (e ArcaneApiEndpoints) UpdaterRun(envID string) string {
- return fmt.Sprintf(e.UpdaterRunEndpoint, envID)
-}
-
-func (e ArcaneApiEndpoints) UpdaterHistory(envID string) string {
- return fmt.Sprintf(e.UpdaterHistoryEndpoint, envID)
+func UpdaterStatus(envID string) string { return pathf("/api/environments/%s/updater/status", envID) }
+func UpdaterRun(envID string) string { return pathf("/api/environments/%s/updater/run", envID) }
+func UpdaterHistory(envID string) string {
+ return pathf("/api/environments/%s/updater/history", envID)
}
-// Job schedule endpoints
+// Job endpoints
-func (e ArcaneApiEndpoints) JobSchedules(envID string) string {
- return fmt.Sprintf(e.JobSchedulesEndpoint, envID)
+func JobSchedules(envID string) string { return pathf("/api/environments/%s/job-schedules", envID) }
+func Jobs(envID string) string { return pathf("/api/environments/%s/jobs", envID) }
+func JobRun(envID, jobID string) string {
+ return pathf("/api/environments/%s/jobs/%s/run", envID, jobID)
}
// Settings endpoints
-func (e ArcaneApiEndpoints) Settings(envID string) string {
- return fmt.Sprintf(e.SettingsEndpoint, envID)
-}
-
-func (e ArcaneApiEndpoints) SettingsPublic(envID string) string {
- return fmt.Sprintf(e.SettingsPublicEndpoint, envID)
+func Settings(envID string) string { return pathf("/api/environments/%s/settings", envID) }
+func SettingsPublic(envID string) string {
+ return pathf("/api/environments/%s/settings/public", envID)
}
// Notification endpoints
-func (e ArcaneApiEndpoints) NotificationsSettings(envID string) string {
- return fmt.Sprintf(e.NotificationsSettingsEndpoint, envID)
+func NotificationsSettings(envID string) string {
+ return pathf("/api/environments/%s/notifications/settings", envID)
}
-
-func (e ArcaneApiEndpoints) NotificationSettingsProvider(envID, provider string) string {
- return fmt.Sprintf(e.NotificationSettingsProviderEndpoint, envID, provider)
+func NotificationSettingsProvider(envID, provider string) string {
+ return pathf("/api/environments/%s/notifications/settings/%s", envID, provider)
}
-
-func (e ArcaneApiEndpoints) NotificationsTestProvider(envID, provider string) string {
- return fmt.Sprintf(e.NotificationsTestProviderEndpoint, envID, provider)
+func NotificationsTestProvider(envID, provider string) string {
+ return pathf("/api/environments/%s/notifications/test/%s", envID, provider)
}
-// Container Registry endpoints
-
-func (e ArcaneApiEndpoints) ContainerRegistries() string { return e.ContainerRegistriesEndpoint }
+// Container registry endpoints
-func (e ArcaneApiEndpoints) ContainerRegistry(id string) string {
- return fmt.Sprintf(e.ContainerRegistryEndpoint, id)
-}
-func (e ArcaneApiEndpoints) ContainerRegistryTest(id string) string {
- return fmt.Sprintf(e.ContainerRegistryTestEndpoint, id)
+func ContainerRegistries() string { return "/api/container-registries" }
+func ContainerRegistry(id string) string { return pathf("/api/container-registries/%s", id) }
+func ContainerRegistryTest(id string) string {
+ return pathf("/api/container-registries/%s/test", id)
}
+func ContainerRegistriesPullUsage() string { return "/api/container-registries/pull-usage" }
// Event endpoints
-func (e ArcaneApiEndpoints) Events() string { return e.EventsEndpoint }
-func (e ArcaneApiEndpoints) Event(id string) string { return fmt.Sprintf(e.EventEndpoint, id) }
-func (e ArcaneApiEndpoints) EventsEnvironment(envID string) string {
- return fmt.Sprintf(e.EventsEnvironmentEndpoint, envID)
+func Events() string { return "/api/events" }
+func Event(id string) string { return pathf("/api/events/%s", id) }
+func EventsEnvironment(envID string) string {
+ return pathf("/api/events/environment/%s", envID)
}
+func EventsStats() string { return "/api/events/stats" }
// Template endpoints
-func (e ArcaneApiEndpoints) Templates() string { return e.TemplatesEndpoint }
-func (e ArcaneApiEndpoints) Template(id string) string { return fmt.Sprintf(e.TemplateEndpoint, id) }
-func (e ArcaneApiEndpoints) TemplatesAll() string { return e.TemplatesAllEndpoint }
-func (e ArcaneApiEndpoints) TemplatesDefault() string { return e.TemplatesDefaultEndpoint }
-func (e ArcaneApiEndpoints) TemplatesRegistries() string { return e.TemplatesRegistriesEndpoint }
-func (e ArcaneApiEndpoints) TemplateRegistry(id string) string {
- return fmt.Sprintf(e.TemplateRegistryEndpoint, id)
+func Templates() string { return "/api/templates" }
+func Template(id string) string { return pathf("/api/templates/%s", id) }
+func TemplatesAll() string { return "/api/templates/all" }
+func TemplatesDefault() string { return "/api/templates/default" }
+func TemplatesRegistries() string { return "/api/templates/registries" }
+func TemplateRegistry(id string) string {
+ return pathf("/api/templates/registries/%s", id)
}
-func (e ArcaneApiEndpoints) TemplatesVariables() string { return e.TemplatesVariablesEndpoint }
+func TemplateContent(id string) string { return pathf("/api/templates/%s/content", id) }
+func TemplateDownload(id string) string { return pathf("/api/templates/%s/download", id) }
+func TemplateFetch() string { return "/api/templates/fetch" }
-// Variable returns the path for a single global variable.
-func (e ArcaneApiEndpoints) Variable(id string) string {
- return fmt.Sprintf(e.VariableEndpoint, id)
-}
-func (e ArcaneApiEndpoints) TemplateContent(id string) string {
- return fmt.Sprintf(e.TemplateContentEndpoint, id)
-}
-func (e ArcaneApiEndpoints) TemplateDownload(id string) string {
- return fmt.Sprintf(e.TemplateDownloadEndpoint, id)
-}
-func (e ArcaneApiEndpoints) TemplateFetch() string { return e.TemplateFetchEndpoint }
+// Variable endpoints
-// Dashboard endpoints
+func Variables() string { return "/api/variables" }
+func Variable(id string) string { return pathf("/api/variables/%s", id) }
+func VariablesSync() string { return "/api/variables/sync" }
+func VariablesSyncStatus() string { return "/api/variables/sync-status" }
-func (e ArcaneApiEndpoints) Dashboard(envID string) string {
- return fmt.Sprintf(e.DashboardEndpoint, envID)
-}
+// TemplatesVariables is the historical alias for the global variables listing.
+func TemplatesVariables() string { return "/api/variables" }
+
+// System backup endpoints (admin-only)
-// GitOps Sync endpoints
+func Backups() string { return "/api/backups" }
+func Backup(id string) string { return pathf("/api/backups/%s", id) }
+func BackupsPolicies() string { return "/api/backups/policies" }
+func BackupsRecoveryKey() string { return "/api/backups/recovery-key" }
+func BackupsRecoveryKeyGenerate() string { return "/api/backups/recovery-key/generate" }
+func BackupsDiscover() string { return "/api/backups/discover" }
+func BackupRestore(id string) string { return pathf("/api/backups/%s/restore", id) }
+func BackupUpload(id string) string { return pathf("/api/backups/%s/upload", id) }
-func (e ArcaneApiEndpoints) GitOpsSyncs(envID string) string {
- return fmt.Sprintf(e.GitOpsSyncsEndpoint, envID)
+// S3 backup destination endpoints (admin-only)
+
+func BackupsS3() string { return "/api/backups/s3" }
+func BackupsS3Options() string { return "/api/backups/s3/options" }
+func BackupsS3Destination(id string) string {
+ return pathf("/api/backups/s3/%s", id)
+}
+func BackupsS3Test() string { return "/api/backups/s3/test" }
+func BackupsS3DestinationTest(id string) string {
+ return pathf("/api/backups/s3/%s/test", id)
+}
+func BackupsS3DestinationInUse(id string) string {
+ return pathf("/api/backups/s3/%s/in-use", id)
}
-func (e ArcaneApiEndpoints) GitOpsSync(envID, syncID string) string {
- return fmt.Sprintf(e.GitOpsSyncEndpoint, envID, syncID)
+
+// GitOps sync endpoints
+
+func GitOpsSyncs(envID string) string { return pathf("/api/environments/%s/gitops-syncs", envID) }
+func GitOpsSync(envID, syncID string) string {
+ return pathf("/api/environments/%s/gitops-syncs/%s", envID, syncID)
}
-func (e ArcaneApiEndpoints) GitOpsSyncStatus(envID, syncID string) string {
- return fmt.Sprintf(e.GitOpsSyncStatusEndpoint, envID, syncID)
+func GitOpsSyncStatus(envID, syncID string) string {
+ return pathf("/api/environments/%s/gitops-syncs/%s/status", envID, syncID)
}
-func (e ArcaneApiEndpoints) GitOpsSyncTrigger(envID, syncID string) string {
- return fmt.Sprintf(e.GitOpsSyncTriggerEndpoint, envID, syncID)
+func GitOpsSyncTrigger(envID, syncID string) string {
+ return pathf("/api/environments/%s/gitops-syncs/%s/sync", envID, syncID)
}
-func (e ArcaneApiEndpoints) GitOpsSyncFiles(envID, syncID string) string {
- return fmt.Sprintf(e.GitOpsSyncFilesEndpoint, envID, syncID)
+func GitOpsSyncFiles(envID, syncID string) string {
+ return pathf("/api/environments/%s/gitops-syncs/%s/files", envID, syncID)
}
-func (e ArcaneApiEndpoints) GitOpsSyncsImport(envID string) string {
- return fmt.Sprintf(e.GitOpsSyncsImportEndpoint, envID)
+func GitOpsSyncsImport(envID string) string {
+ return pathf("/api/environments/%s/gitops-syncs/import", envID)
}
-// Git Repository endpoints
+// Git repository endpoints
-func (e ArcaneApiEndpoints) GitRepositories() string { return e.GitRepositoriesEndpoint }
-func (e ArcaneApiEndpoints) GitRepository(id string) string {
- return fmt.Sprintf(e.GitRepositoryEndpoint, id)
-}
-func (e ArcaneApiEndpoints) GitRepositoryTest(id string) string {
- return fmt.Sprintf(e.GitRepositoryTestEndpoint, id)
+func GitRepositories() string { return "/api/customize/git-repositories" }
+func GitRepository(id string) string { return pathf("/api/customize/git-repositories/%s", id) }
+func GitRepositoryTest(id string) string {
+ return pathf("/api/customize/git-repositories/%s/test", id)
}
-func (e ArcaneApiEndpoints) GitRepositoryBranches(id string) string {
- return fmt.Sprintf(e.GitRepositoryBranchesEndpoint, id)
+func GitRepositoryBranches(id string) string {
+ return pathf("/api/customize/git-repositories/%s/branches", id)
}
-func (e ArcaneApiEndpoints) GitRepositoryFiles(id string) string {
- return fmt.Sprintf(e.GitRepositoryFilesEndpoint, id)
+func GitRepositoryFiles(id string) string {
+ return pathf("/api/customize/git-repositories/%s/files", id)
}
diff --git a/cli/pkg/admin/apikeys/cmd.go b/cli/pkg/admin/apikeys/cmd.go
index 698309d82..b463c7b36 100644
--- a/cli/pkg/admin/apikeys/cmd.go
+++ b/cli/pkg/admin/apikeys/cmd.go
@@ -79,8 +79,8 @@ func parsePermissionGrantsInternal(tokens []string) ([]apikey.PermissionGrant, e
// ApiKeysCmd is the parent command for API key operations
var ApiKeysCmd = &cobra.Command{
- Use: "api-keys",
- Aliases: []string{"apikey", "keys", "key"},
+ Use: "keys",
+ Aliases: []string{"api-keys", "apikey", "key"},
Short: "Manage API keys",
}
@@ -95,7 +95,7 @@ var listCmd = &cobra.Command{
return err
}
- path := types.Endpoints.ApiKeys()
+ path := types.ApiKeys()
path, err = cmdutil.ApplyPaginationParams(cmd, path, cmdutil.ListParams{Resource: "apikeys", Limit: limitFlag, FallbackDefault: 20, Start: startFlag, All: allFlag})
if err != nil {
return errors.WrapIf(err, "failed to build pagination query")
@@ -178,7 +178,7 @@ var createCmd = &cobra.Command{
createReq.ExpiresAt = &parsed
}
- resp, err := c.Post(cmd.Context(), types.Endpoints.ApiKeys(), createReq)
+ resp, err := c.Post(cmd.Context(), types.ApiKeys(), createReq)
if err != nil {
return errors.WrapIf(err, "failed to create API key")
}
@@ -227,7 +227,7 @@ var deleteCmd = &cobra.Command{
return err
}
- resp, err := c.Delete(cmd.Context(), types.Endpoints.ApiKey(args[0]))
+ resp, err := c.Delete(cmd.Context(), types.ApiKey(args[0]))
if err != nil {
return errors.WrapIf(err, "failed to delete API key")
}
@@ -260,7 +260,7 @@ var getCmd = &cobra.Command{
return err
}
- resp, err := c.Get(cmd.Context(), types.Endpoints.ApiKey(args[0]))
+ resp, err := c.Get(cmd.Context(), types.ApiKey(args[0]))
if err != nil {
return errors.WrapIf(err, "failed to get API key")
}
@@ -340,7 +340,7 @@ var updateCmd = &cobra.Command{
req.Permissions = &grants
}
- resp, err := c.Put(cmd.Context(), types.Endpoints.ApiKey(args[0]), req)
+ resp, err := c.Put(cmd.Context(), types.ApiKey(args[0]), req)
if err != nil {
return errors.WrapIf(err, "failed to update API key")
}
diff --git a/cli/pkg/admin/cmd.go b/cli/pkg/admin/cmd.go
index 0c00dc78d..f63bf074a 100644
--- a/cli/pkg/admin/cmd.go
+++ b/cli/pkg/admin/cmd.go
@@ -3,6 +3,7 @@ package admin
import (
"github.com/getarcaneapp/arcane/cli/v2/pkg/admin/apikeys"
"github.com/getarcaneapp/arcane/cli/v2/pkg/admin/events"
+ "github.com/getarcaneapp/arcane/cli/v2/pkg/admin/federatedcredentials"
"github.com/getarcaneapp/arcane/cli/v2/pkg/admin/notifications"
"github.com/getarcaneapp/arcane/cli/v2/pkg/admin/oidcmappings"
"github.com/getarcaneapp/arcane/cli/v2/pkg/admin/roles"
@@ -22,6 +23,7 @@ func init() {
AdminCmd.AddCommand(roles.RolesCmd)
AdminCmd.AddCommand(oidcmappings.OidcMappingsCmd)
AdminCmd.AddCommand(apikeys.ApiKeysCmd)
+ AdminCmd.AddCommand(federatedcredentials.FederatedCredentialsCmd)
AdminCmd.AddCommand(events.EventsCmd)
AdminCmd.AddCommand(notifications.NotificationsCmd)
}
diff --git a/cli/pkg/admin/events/cmd.go b/cli/pkg/admin/events/cmd.go
index 2cdb440a3..47b51c98f 100644
--- a/cli/pkg/admin/events/cmd.go
+++ b/cli/pkg/admin/events/cmd.go
@@ -15,11 +15,12 @@ import (
)
var (
- limitFlag int
- startFlag int
- allFlag bool
- forceFlag bool
- jsonOutput bool
+ limitFlag int
+ startFlag int
+ allFlag bool
+ forceFlag bool
+ jsonOutput bool
+ envOnlyFlag bool
)
// EventsCmd is the parent command for event operations
@@ -40,69 +41,10 @@ var listCmd = &cobra.Command{
return err
}
- path := types.Endpoints.Events()
- path, err = cmdutil.ApplyPaginationParams(cmd, path, cmdutil.ListParams{Resource: "events", Limit: limitFlag, FallbackDefault: 20, Start: startFlag, All: allFlag})
- if err != nil {
- return errors.WrapIf(err, "failed to build pagination query")
- }
-
- resp, err := c.Get(cmd.Context(), path)
- if err != nil {
- return errors.WrapIf(err, "failed to list events")
- }
- defer func() { _ = resp.Body.Close() }()
-
- var result base.Paginated[event.Event]
- if err := cmdutil.DecodeJSON(resp, &result); err != nil {
- return err
- }
-
- if jsonOutput {
- resultBytes, err := json.MarshalIndent(result, "", " ")
- if err != nil {
- return errors.WrapIf(err, "failed to marshal JSON")
- }
- fmt.Println(string(resultBytes))
- return nil
- }
-
- headers := []string{"ID", "TYPE", "RESOURCE", "USER", "TIMESTAMP"}
- rows := make([][]string, len(result.Data))
- for i, evt := range result.Data {
- resource := ""
- if evt.ResourceName != nil && evt.ResourceType != nil {
- resource = fmt.Sprintf("%s (%s)", *evt.ResourceName, *evt.ResourceType)
- }
- username := ""
- if evt.Username != nil {
- username = *evt.Username
- }
- rows[i] = []string{
- evt.ID,
- evt.Type,
- resource,
- username,
- evt.Timestamp.String(),
- }
+ path := types.Events()
+ if envOnlyFlag {
+ path = types.EventsEnvironment(c.EnvID())
}
-
- output.Table(headers, rows)
- output.Showing(len(result.Data), result.Pagination.TotalItems, "events")
- return nil
- },
-}
-
-var listEnvCmd = &cobra.Command{
- Use: "list-env",
- Short: "List events for current environment",
- SilenceUsage: true,
- RunE: func(cmd *cobra.Command, args []string) error {
- c, err := client.NewFromConfig()
- if err != nil {
- return err
- }
-
- path := types.Endpoints.EventsEnvironment(c.EnvID())
path, err = cmdutil.ApplyPaginationParams(cmd, path, cmdutil.ListParams{Resource: "events", Limit: limitFlag, FallbackDefault: 20, Start: startFlag, All: allFlag})
if err != nil {
return errors.WrapIf(err, "failed to build pagination query")
@@ -110,7 +52,7 @@ var listEnvCmd = &cobra.Command{
resp, err := c.Get(cmd.Context(), path)
if err != nil {
- return errors.WrapIf(err, "failed to list environment events")
+ return errors.WrapIf(err, "failed to list events")
}
defer func() { _ = resp.Body.Close() }()
@@ -177,7 +119,7 @@ var deleteCmd = &cobra.Command{
return err
}
- resp, err := c.Delete(cmd.Context(), types.Endpoints.Event(args[0]))
+ resp, err := c.Delete(cmd.Context(), types.Event(args[0]))
if err != nil {
return errors.WrapIf(err, "failed to delete event")
}
@@ -191,21 +133,68 @@ var deleteCmd = &cobra.Command{
},
}
+var statsCmd = &cobra.Command{
+ Use: "stats",
+ Short: "Show global event counts by severity",
+ SilenceUsage: true,
+ RunE: func(cmd *cobra.Command, args []string) error {
+ c, err := client.NewFromConfig()
+ if err != nil {
+ return err
+ }
+
+ resp, err := c.Get(cmd.Context(), types.EventsStats())
+ if err != nil {
+ return errors.WrapIf(err, "failed to get event stats")
+ }
+ defer func() { _ = resp.Body.Close() }()
+
+ // The severity counts DTO lives only in the backend's internal event
+ // package, so mirror its wire shape here.
+ var result base.ApiResponse[struct {
+ Total int64 `json:"total"`
+ Info int64 `json:"info"`
+ Success int64 `json:"success"`
+ Warning int64 `json:"warning"`
+ Error int64 `json:"error"`
+ }]
+ if err := cmdutil.DecodeJSON(resp, &result); err != nil {
+ return err
+ }
+
+ if jsonOutput {
+ resultBytes, err := json.MarshalIndent(result.Data, "", " ")
+ if err != nil {
+ return errors.WrapIf(err, "failed to marshal JSON")
+ }
+ fmt.Println(string(resultBytes))
+ return nil
+ }
+
+ output.Header("Event Stats")
+ output.KeyValue("Total", result.Data.Total)
+ output.KeyValue("Info", result.Data.Info)
+ output.KeyValue("Success", result.Data.Success)
+ output.KeyValue("Warning", result.Data.Warning)
+ output.KeyValue("Error", result.Data.Error)
+ return nil
+ },
+}
+
func init() {
EventsCmd.AddCommand(listCmd)
- EventsCmd.AddCommand(listEnvCmd)
EventsCmd.AddCommand(deleteCmd)
+ EventsCmd.AddCommand(statsCmd)
listCmd.Flags().IntVarP(&limitFlag, "limit", "n", 20, "Number of events to show")
listCmd.Flags().IntVar(&startFlag, "start", 0, cmdutil.StartFlagUsage)
listCmd.Flags().BoolVarP(&allFlag, "all", "a", false, cmdutil.AllFlagUsage)
listCmd.Flags().BoolVar(&jsonOutput, "json", false, "Output in JSON format")
- listEnvCmd.Flags().IntVarP(&limitFlag, "limit", "n", 20, "Number of events to show")
- listEnvCmd.Flags().IntVar(&startFlag, "start", 0, cmdutil.StartFlagUsage)
- listEnvCmd.Flags().BoolVarP(&allFlag, "all", "a", false, cmdutil.AllFlagUsage)
- listEnvCmd.Flags().BoolVar(&jsonOutput, "json", false, "Output in JSON format")
+ listCmd.Flags().BoolVar(&envOnlyFlag, "environment", false, "Only list events for the current environment")
deleteCmd.Flags().BoolVarP(&forceFlag, "force", "f", false, "Force deletion without confirmation")
deleteCmd.Flags().BoolVar(&jsonOutput, "json", false, "Output in JSON format")
+
+ statsCmd.Flags().BoolVar(&jsonOutput, "json", false, "Output in JSON format")
}
diff --git a/cli/pkg/admin/federatedcredentials/cmd.go b/cli/pkg/admin/federatedcredentials/cmd.go
new file mode 100644
index 000000000..0b1ed7750
--- /dev/null
+++ b/cli/pkg/admin/federatedcredentials/cmd.go
@@ -0,0 +1,419 @@
+// Package federatedcredentials provides the `arcane admin federated` command
+// tree. Federated credentials are workload identity federation trust rules:
+// an external OIDC token matching the rule is exchanged for a short-lived
+// Arcane access token backed by a dedicated service user.
+package federatedcredentials
+
+import (
+ "fmt"
+ "time"
+
+ "emperror.dev/errors"
+ "github.com/getarcaneapp/arcane/cli/v2/internal/cmdutil"
+ "github.com/getarcaneapp/arcane/cli/v2/internal/output"
+ "github.com/getarcaneapp/arcane/cli/v2/internal/types"
+ "github.com/getarcaneapp/arcane/types/v2/base"
+ federatedtypes "github.com/getarcaneapp/arcane/types/v2/federated"
+ "github.com/spf13/cobra"
+)
+
+var (
+ limitFlag int
+ startFlag int
+ allFlag bool
+ forceFlag bool
+ jsonOutput bool
+)
+
+var (
+ createName string
+ createDescription string
+ createDisabled bool
+ createIssuerURL string
+ createAudiences []string
+ createSubjectClaim string
+ createSubjectMatch string
+ createMatchType string
+ createRoleID string
+ createEnvironment string
+ createTokenTTL int
+ createExpiresAt string
+)
+
+var (
+ updateName string
+ updateDescription string
+ updateEnabled bool
+ updateDisabled bool
+ updateIssuerURL string
+ updateAudiences []string
+ updateSubjectClaim string
+ updateSubjectMatch string
+ updateMatchType string
+ updateRoleID string
+ updateTokenTTL int
+ updateExpiresAt string
+)
+
+// FederatedCredentialsCmd is the parent command for federated credential operations.
+var FederatedCredentialsCmd = &cobra.Command{
+ Use: "federated",
+ Aliases: []string{"fedcreds", "federated-credentials"},
+ Short: "Manage workload identity federation trust rules",
+}
+
+var listCmd = &cobra.Command{
+ Use: "list",
+ Aliases: []string{"ls"},
+ Short: "List federated credentials",
+ SilenceUsage: true,
+ RunE: func(cmd *cobra.Command, args []string) error {
+ c, err := cmdutil.ClientFromCommand(cmd)
+ if err != nil {
+ return err
+ }
+
+ path, err := cmdutil.ApplyPaginationParams(cmd, types.FederatedCredentials(), cmdutil.ListParams{
+ Resource: "federated-credentials",
+ Limit: limitFlag,
+ FallbackDefault: 20,
+ Start: startFlag,
+ All: allFlag,
+ })
+ if err != nil {
+ return errors.WrapIf(err, "failed to build pagination query")
+ }
+
+ resp, err := c.Get(cmd.Context(), path)
+ if err != nil {
+ return errors.WrapIf(err, "failed to list federated credentials")
+ }
+ defer func() { _ = resp.Body.Close() }()
+
+ var result base.Paginated[federatedtypes.FederatedCredential]
+ if err := cmdutil.DecodeJSON(resp, &result); err != nil {
+ return errors.WrapIf(err, "failed to list federated credentials")
+ }
+
+ if jsonOutput {
+ return cmdutil.PrintJSON(result.Data)
+ }
+
+ headers := []string{"ID", "NAME", "ISSUER", "SUBJECT", "ROLE", "ENABLED"}
+ rows := make([][]string, len(result.Data))
+ for i, cred := range result.Data {
+ role := cred.RoleName
+ if role == "" {
+ role = cred.RoleID
+ }
+ enabled := "false"
+ if cred.Enabled {
+ enabled = "true"
+ }
+ rows[i] = []string{cred.ID, cred.Name, cred.IssuerURL, cred.SubjectMatch, role, enabled}
+ }
+ output.Table(headers, rows)
+ output.Showing(len(result.Data), result.Pagination.TotalItems, "federated credentials")
+ return nil
+ },
+}
+
+var getCmd = &cobra.Command{
+ Use: "get <credential-id>",
+ Short: "Get federated credential 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
+ }
+
+ resp, err := c.Get(cmd.Context(), types.FederatedCredential(args[0]))
+ if err != nil {
+ return errors.WrapIf(err, "failed to get federated credential")
+ }
+ defer func() { _ = resp.Body.Close() }()
+
+ var result base.ApiResponse[federatedtypes.FederatedCredential]
+ if err := cmdutil.DecodeJSON(resp, &result); err != nil {
+ return errors.WrapIf(err, "failed to get federated credential")
+ }
+
+ if jsonOutput {
+ return cmdutil.PrintJSON(result.Data)
+ }
+
+ printCredentialInternal(result.Data)
+ return nil
+ },
+}
+
+var createCmd = &cobra.Command{
+ Use: "create",
+ Short: "Create a federated credential",
+ Example: ` arcane admin federated create --name github-actions --issuer-url https://token.actions.githubusercontent.com \
+ --audience arcane --subject-match "repo:myorg/*" --match-type glob --role role_deployer`,
+ SilenceUsage: true,
+ RunE: func(cmd *cobra.Command, args []string) error {
+ c, err := cmdutil.ClientFromCommand(cmd)
+ if err != nil {
+ return err
+ }
+
+ req := federatedtypes.CreateFederatedCredential{
+ Name: createName,
+ Enabled: !createDisabled,
+ IssuerURL: createIssuerURL,
+ Audiences: createAudiences,
+ SubjectClaim: createSubjectClaim,
+ SubjectMatch: createSubjectMatch,
+ MatchType: createMatchType,
+ RoleID: createRoleID,
+ }
+ if cmd.Flags().Changed("description") {
+ req.Description = &createDescription
+ }
+ if cmd.Flags().Changed("environment") && createEnvironment != "" {
+ req.EnvironmentID = new(createEnvironment)
+ }
+ if cmd.Flags().Changed("token-ttl") {
+ req.TokenTTLSeconds = createTokenTTL
+ }
+ if createExpiresAt != "" {
+ parsed, err := time.Parse(time.RFC3339, createExpiresAt)
+ if err != nil {
+ return errors.WrapIf(err, "invalid --expires-at format (use RFC3339)")
+ }
+ req.ExpiresAt = &parsed
+ }
+
+ resp, err := c.Post(cmd.Context(), types.FederatedCredentials(), req)
+ if err != nil {
+ return errors.WrapIf(err, "failed to create federated credential")
+ }
+ defer func() { _ = resp.Body.Close() }()
+
+ var result base.ApiResponse[federatedtypes.FederatedCredential]
+ if err := cmdutil.DecodeJSON(resp, &result); err != nil {
+ return errors.WrapIf(err, "failed to create federated credential")
+ }
+
+ if jsonOutput {
+ return cmdutil.PrintJSON(result.Data)
+ }
+
+ output.Success("Federated credential created")
+ printCredentialInternal(result.Data)
+ return nil
+ },
+}
+
+var updateCmd = &cobra.Command{
+ Use: "update <credential-id>",
+ Short: "Update a federated credential",
+ Args: cobra.ExactArgs(1),
+ SilenceUsage: true,
+ RunE: func(cmd *cobra.Command, args []string) error {
+ if cmd.Flags().Changed("enabled") && cmd.Flags().Changed("disabled") {
+ return errors.New("--enabled and --disabled are mutually exclusive")
+ }
+
+ c, err := cmdutil.ClientFromCommand(cmd)
+ if err != nil {
+ return err
+ }
+
+ var req federatedtypes.UpdateFederatedCredential
+ if cmd.Flags().Changed("name") {
+ req.Name = &updateName
+ }
+ if cmd.Flags().Changed("description") {
+ req.Description = &updateDescription
+ }
+ if cmd.Flags().Changed("enabled") {
+ req.Enabled = new(true)
+ }
+ if cmd.Flags().Changed("disabled") {
+ req.Enabled = new(false)
+ }
+ if cmd.Flags().Changed("issuer-url") {
+ req.IssuerURL = &updateIssuerURL
+ }
+ if cmd.Flags().Changed("audience") {
+ req.Audiences = updateAudiences
+ }
+ if cmd.Flags().Changed("subject-claim") {
+ req.SubjectClaim = &updateSubjectClaim
+ }
+ if cmd.Flags().Changed("subject-match") {
+ req.SubjectMatch = &updateSubjectMatch
+ }
+ if cmd.Flags().Changed("match-type") {
+ req.MatchType = &updateMatchType
+ }
+ if cmd.Flags().Changed("role") {
+ req.RoleID = &updateRoleID
+ }
+ if cmd.Flags().Changed("environment") {
+ env, _ := cmd.Flags().GetString("environment")
+ if env != "" {
+ req.EnvironmentID = &env
+ }
+ }
+ if cmd.Flags().Changed("token-ttl") {
+ req.TokenTTLSeconds = &updateTokenTTL
+ }
+ if cmd.Flags().Changed("expires-at") && updateExpiresAt != "" {
+ parsed, err := time.Parse(time.RFC3339, updateExpiresAt)
+ if err != nil {
+ return errors.WrapIf(err, "invalid --expires-at format (use RFC3339)")
+ }
+ req.ExpiresAt = &parsed
+ }
+
+ resp, err := c.Put(cmd.Context(), types.FederatedCredential(args[0]), req)
+ if err != nil {
+ return errors.WrapIf(err, "failed to update federated credential")
+ }
+ defer func() { _ = resp.Body.Close() }()
+
+ var result base.ApiResponse[federatedtypes.FederatedCredential]
+ if err := cmdutil.DecodeJSON(resp, &result); err != nil {
+ return errors.WrapIf(err, "failed to update federated credential")
+ }
+
+ if jsonOutput {
+ return cmdutil.PrintJSON(result.Data)
+ }
+
+ output.Success("Federated credential updated")
+ printCredentialInternal(result.Data)
+ return nil
+ },
+}
+
+var deleteCmd = &cobra.Command{
+ Use: "delete <credential-id>",
+ Aliases: []string{"rm", "remove"},
+ Short: "Delete a federated credential",
+ Args: cobra.ExactArgs(1),
+ SilenceUsage: true,
+ RunE: func(cmd *cobra.Command, args []string) error {
+ if !forceFlag {
+ confirmed, err := cmdutil.Confirm(cmd, fmt.Sprintf("Delete federated credential %s and its service user?", args[0]))
+ if err != nil {
+ return err
+ }
+ if !confirmed {
+ fmt.Println("Cancelled")
+ return nil
+ }
+ }
+
+ c, err := cmdutil.ClientFromCommand(cmd)
+ if err != nil {
+ return err
+ }
+
+ resp, err := c.Delete(cmd.Context(), types.FederatedCredential(args[0]))
+ if err != nil {
+ return errors.WrapIf(err, "failed to delete federated credential")
+ }
+ defer func() { _ = resp.Body.Close() }()
+ if err := cmdutil.EnsureSuccessStatus(resp); err != nil {
+ return errors.WrapIf(err, "failed to delete federated credential")
+ }
+
+ output.Success("Federated credential deleted")
+ return nil
+ },
+}
+
+func printCredentialInternal(cred federatedtypes.FederatedCredential) {
+ output.KeyValue("ID", cred.ID)
+ output.KeyValue("Name", cred.Name)
+ if cred.Description != nil && *cred.Description != "" {
+ output.KeyValue("Description", *cred.Description)
+ }
+ output.KeyValue("Enabled", cred.Enabled)
+ output.KeyValue("Issuer URL", cred.IssuerURL)
+ output.KeyValue("Audiences", cred.Audiences)
+ output.KeyValue("Subject claim", cred.SubjectClaim)
+ output.KeyValue("Subject match", cred.SubjectMatch)
+ output.KeyValue("Match type", cred.MatchType)
+ role := cred.RoleName
+ if role == "" {
+ role = cred.RoleID
+ }
+ output.KeyValue("Role", role)
+ scope := "global"
+ if cred.EnvironmentID != nil {
+ scope = *cred.EnvironmentID
+ if cred.EnvironmentName != "" {
+ scope = fmt.Sprintf("%s (%s)", cred.EnvironmentName, *cred.EnvironmentID)
+ }
+ }
+ output.KeyValue("Scope", scope)
+ output.KeyValue("Token TTL (s)", cred.TokenTTLSeconds)
+ if cred.ServiceUsername != "" {
+ output.KeyValue("Service user", cred.ServiceUsername)
+ }
+ if cred.LastUsedAt != nil {
+ output.KeyValue("Last used", cred.LastUsedAt.Format("2006-01-02 15:04"))
+ }
+ if cred.ExpiresAt != nil {
+ output.KeyValue("Expires", cred.ExpiresAt.Format("2006-01-02 15:04"))
+ }
+}
+
+func init() {
+ FederatedCredentialsCmd.AddCommand(listCmd)
+ FederatedCredentialsCmd.AddCommand(getCmd)
+ FederatedCredentialsCmd.AddCommand(createCmd)
+ FederatedCredentialsCmd.AddCommand(updateCmd)
+ FederatedCredentialsCmd.AddCommand(deleteCmd)
+
+ listCmd.Flags().IntVarP(&limitFlag, "limit", "n", 20, "Number of federated credentials to show")
+ listCmd.Flags().IntVar(&startFlag, "start", 0, cmdutil.StartFlagUsage)
+ listCmd.Flags().BoolVarP(&allFlag, "all", "a", false, cmdutil.AllFlagUsage)
+ listCmd.Flags().BoolVar(&jsonOutput, "json", false, "Output in JSON format")
+
+ getCmd.Flags().BoolVar(&jsonOutput, "json", false, "Output in JSON format")
+
+ createCmd.Flags().StringVar(&createName, "name", "", "Display name (required)")
+ createCmd.Flags().StringVar(&createDescription, "description", "", "Description")
+ createCmd.Flags().BoolVar(&createDisabled, "disabled", false, "Create the trust rule in disabled state")
+ createCmd.Flags().StringVar(&createIssuerURL, "issuer-url", "", "Trusted external OIDC issuer URL (required)")
+ createCmd.Flags().StringArrayVar(&createAudiences, "audience", nil, "Allowed external token audience (repeatable, required)")
+ createCmd.Flags().StringVar(&createSubjectClaim, "subject-claim", "", "Claim path to match against (defaults to sub)")
+ createCmd.Flags().StringVar(&createSubjectMatch, "subject-match", "", "Exact subject or anchored glob pattern (required)")
+ createCmd.Flags().StringVar(&createMatchType, "match-type", "", "Subject match strategy: exact or glob")
+ createCmd.Flags().StringVar(&createRoleID, "role", "", "Role ID to map exchanged tokens to (required)")
+ createCmd.Flags().StringVar(&createEnvironment, "environment", "", "Scope the role assignment to one environment (omit for global)")
+ createCmd.Flags().IntVar(&createTokenTTL, "token-ttl", 0, "Issued token lifetime in seconds (60-3600)")
+ createCmd.Flags().StringVar(&createExpiresAt, "expires-at", "", "Credential expiration (RFC3339 format)")
+ createCmd.Flags().BoolVar(&jsonOutput, "json", false, "Output in JSON format")
+ _ = createCmd.MarkFlagRequired("name")
+ _ = createCmd.MarkFlagRequired("issuer-url")
+ _ = createCmd.MarkFlagRequired("audience")
+ _ = createCmd.MarkFlagRequired("subject-match")
+ _ = createCmd.MarkFlagRequired("role")
+
+ updateCmd.Flags().StringVar(&updateName, "name", "", "New display name")
+ updateCmd.Flags().StringVar(&updateDescription, "description", "", "New description")
+ updateCmd.Flags().BoolVar(&updateEnabled, "enabled", false, "Enable the trust rule")
+ updateCmd.Flags().BoolVar(&updateDisabled, "disabled", false, "Disable the trust rule")
+ updateCmd.Flags().StringVar(&updateIssuerURL, "issuer-url", "", "New issuer URL")
+ updateCmd.Flags().StringArrayVar(&updateAudiences, "audience", nil, "Replace allowed audiences (repeatable)")
+ updateCmd.Flags().StringVar(&updateSubjectClaim, "subject-claim", "", "New claim path to match against")
+ updateCmd.Flags().StringVar(&updateSubjectMatch, "subject-match", "", "New subject match pattern")
+ updateCmd.Flags().StringVar(&updateMatchType, "match-type", "", "New match strategy: exact or glob")
+ updateCmd.Flags().StringVar(&updateRoleID, "role", "", "New role ID")
+ updateCmd.Flags().String("environment", "", "New environment scope")
+ updateCmd.Flags().IntVar(&updateTokenTTL, "token-ttl", 0, "New issued token lifetime in seconds (60-3600)")
+ updateCmd.Flags().StringVar(&updateExpiresAt, "expires-at", "", "New credential expiration (RFC3339 format)")
+ updateCmd.Flags().BoolVar(&jsonOutput, "json", false, "Output in JSON format")
+
+ deleteCmd.Flags().BoolVarP(&forceFlag, "force", "f", false, "Force deletion without confirmation")
+}
diff --git a/cli/pkg/admin/notifications/cmd.go b/cli/pkg/admin/notifications/cmd.go
index a3797cbdd..2e409f564 100644
--- a/cli/pkg/admin/notifications/cmd.go
+++ b/cli/pkg/admin/notifications/cmd.go
@@ -3,6 +3,7 @@ package notifications
import (
"encoding/json"
"fmt"
+ "os"
"strconv"
"emperror.dev/errors"
@@ -42,7 +43,7 @@ var settingsGetCmd = &cobra.Command{
return err
}
- resp, err := c.Get(cmd.Context(), types.Endpoints.NotificationsSettings(c.EnvID()))
+ resp, err := c.Get(cmd.Context(), types.NotificationsSettings(c.EnvID()))
if err != nil {
return errors.WrapIf(err, "failed to get settings")
}
@@ -100,7 +101,7 @@ var settingsDeleteCmd = &cobra.Command{
return err
}
- resp, err := c.Delete(cmd.Context(), types.Endpoints.NotificationSettingsProvider(c.EnvID(), args[0]))
+ resp, err := c.Delete(cmd.Context(), types.NotificationSettingsProvider(c.EnvID(), args[0]))
if err != nil {
return errors.WrapIf(err, "failed to delete notification settings")
}
@@ -114,6 +115,78 @@ var settingsDeleteCmd = &cobra.Command{
},
}
+var (
+ setProvider string
+ setEnabled bool
+ setConfig string
+ setFile string
+)
+
+var settingsSetCmd = &cobra.Command{
+ Use: "set",
+ Short: "Create or update notification provider settings",
+ SilenceUsage: true,
+ RunE: func(cmd *cobra.Command, args []string) error {
+ var req notification.Update
+ if setFile != "" {
+ data, err := os.ReadFile(setFile)
+ if err != nil {
+ return errors.WrapIf(err, "failed to read settings file")
+ }
+ if err := json.Unmarshal(data, &req); err != nil {
+ return errors.WrapIf(err, "failed to parse settings file")
+ }
+ }
+
+ if cmd.Flags().Changed("provider") {
+ req.Provider = notification.Provider(setProvider)
+ }
+ if cmd.Flags().Changed("enabled") {
+ req.Enabled = setEnabled
+ }
+ if cmd.Flags().Changed("config") {
+ if err := json.Unmarshal([]byte(setConfig), &req.Config); err != nil {
+ return errors.WrapIf(err, "failed to parse --config JSON")
+ }
+ }
+
+ if req.Provider == "" {
+ return errors.New("provider is required (use --provider or --file)")
+ }
+ if req.Config == nil {
+ return errors.New("config is required (use --config or --file)")
+ }
+
+ c, err := cmdutil.ClientFromCommand(cmd)
+ if err != nil {
+ return err
+ }
+
+ resp, err := c.Post(cmd.Context(), types.NotificationsSettings(c.EnvID()), req)
+ if err != nil {
+ return errors.WrapIf(err, "failed to save notification settings")
+ }
+ defer func() { _ = resp.Body.Close() }()
+ if err := cmdutil.EnsureSuccessStatus(resp); err != nil {
+ return errors.WrapIf(err, "failed to save notification settings")
+ }
+
+ var result notification.Response
+ if err := cmdutil.DecodeJSON(resp, &result); err != nil {
+ return err
+ }
+
+ if jsonOutput {
+ return cmdutil.PrintJSON(result)
+ }
+
+ output.Success("Notification settings for %s saved successfully", result.Provider)
+ output.KeyValue("ID", strconv.FormatUint(uint64(result.ID), 10))
+ output.KeyValue("Enabled", strconv.FormatBool(result.Enabled))
+ return nil
+ },
+}
+
var testProviderCmd = &cobra.Command{
Use: "test <provider>",
Short: "Test a notification provider",
@@ -125,7 +198,7 @@ var testProviderCmd = &cobra.Command{
return err
}
- resp, err := c.Post(cmd.Context(), types.Endpoints.NotificationsTestProvider(c.EnvID(), args[0]), nil)
+ resp, err := c.Post(cmd.Context(), types.NotificationsTestProvider(c.EnvID(), args[0]), nil)
if err != nil {
return errors.WrapIf(err, "failed to test notification provider")
}
@@ -154,9 +227,16 @@ func init() {
NotificationsCmd.AddCommand(testProviderCmd)
settingsCmd.AddCommand(settingsGetCmd)
+ settingsCmd.AddCommand(settingsSetCmd)
settingsCmd.AddCommand(settingsDeleteCmd)
settingsGetCmd.Flags().BoolVar(&jsonOutput, "json", false, "Output in JSON format")
+
+ settingsSetCmd.Flags().StringVar(&setProvider, "provider", "", "Notification provider (e.g. discord, email, telegram)")
+ settingsSetCmd.Flags().BoolVar(&setEnabled, "enabled", false, "Enable the provider")
+ settingsSetCmd.Flags().StringVar(&setConfig, "config", "", "Provider configuration as a JSON object")
+ settingsSetCmd.Flags().StringVar(&setFile, "file", "", "Path to a JSON file with provider, enabled, and config fields")
+ settingsSetCmd.Flags().BoolVar(&jsonOutput, "json", false, "Output in JSON format")
settingsDeleteCmd.Flags().BoolVarP(&notifForceFlag, "force", "f", false, "Force deletion without confirmation")
settingsDeleteCmd.Flags().BoolVar(&jsonOutput, "json", false, "Output in JSON format")
testProviderCmd.Flags().BoolVar(&jsonOutput, "json", false, "Output in JSON format")
diff --git a/cli/pkg/admin/oidcmappings/cmd.go b/cli/pkg/admin/oidcmappings/cmd.go
index c6443399b..9b3f989ba 100644
--- a/cli/pkg/admin/oidcmappings/cmd.go
+++ b/cli/pkg/admin/oidcmappings/cmd.go
@@ -34,8 +34,8 @@ var (
// OidcMappingsCmd is the parent command for OIDC role mapping operations.
var OidcMappingsCmd = &cobra.Command{
- Use: "oidc-mappings",
- Aliases: []string{"oidc-mapping", "oidc"},
+ Use: "oidc",
+ Aliases: []string{"oidc-mappings", "oidc-mapping"},
Short: "Manage OIDC group → role mappings",
Long: "Manage OIDC group → role mappings. On every OIDC login, Arcane " +
"looks up the user's groups claim and applies the matching mappings " +
@@ -53,7 +53,7 @@ var listCmd = &cobra.Command{
if err != nil {
return err
}
- resp, err := c.Get(cmd.Context(), types.Endpoints.OidcRoleMappings())
+ resp, err := c.Get(cmd.Context(), types.OidcRoleMappings())
if err != nil {
return errors.WrapIf(err, "failed to list OIDC mappings")
}
@@ -105,7 +105,7 @@ var createCmd = &cobra.Command{
req.EnvironmentID = new(createEnvironment)
}
- resp, err := c.Post(cmd.Context(), types.Endpoints.OidcRoleMappings(), req)
+ resp, err := c.Post(cmd.Context(), types.OidcRoleMappings(), req)
if err != nil {
return errors.WrapIf(err, "failed to create OIDC mapping")
}
@@ -168,7 +168,7 @@ var updateCmd = &cobra.Command{
}
}
- resp, err := c.Put(cmd.Context(), types.Endpoints.OidcRoleMapping(args[0]), req)
+ resp, err := c.Put(cmd.Context(), types.OidcRoleMapping(args[0]), req)
if err != nil {
return errors.WrapIf(err, "failed to update OIDC mapping")
}
@@ -202,7 +202,7 @@ var deleteCmd = &cobra.Command{
if err != nil {
return err
}
- resp, err := c.Delete(cmd.Context(), types.Endpoints.OidcRoleMapping(args[0]))
+ resp, err := c.Delete(cmd.Context(), types.OidcRoleMapping(args[0]))
if err != nil {
return errors.WrapIf(err, "failed to delete OIDC mapping")
}
@@ -223,7 +223,7 @@ func fetchMappingInternal(cmd *cobra.Command, id string) (*roletypes.OidcRoleMap
if err != nil {
return nil, err
}
- resp, err := c.Get(cmd.Context(), types.Endpoints.OidcRoleMappings())
+ resp, err := c.Get(cmd.Context(), types.OidcRoleMappings())
if err != nil {
return nil, errors.WrapIf(err, "failed to load current mapping")
}
diff --git a/cli/pkg/admin/roles/cmd.go b/cli/pkg/admin/roles/cmd.go
index 501972691..9643da986 100644
--- a/cli/pkg/admin/roles/cmd.go
+++ b/cli/pkg/admin/roles/cmd.go
@@ -66,7 +66,7 @@ var listCmd = &cobra.Command{
return err
}
- path := types.Endpoints.Roles()
+ path := types.Roles()
path, err = cmdutil.ApplyPaginationParams(cmd, path, cmdutil.ListParams{Resource: "roles", Limit: limitFlag, FallbackDefault: 20, Start: startFlag, All: allFlag})
if err != nil {
return errors.WrapIf(err, "failed to build pagination query")
@@ -118,7 +118,7 @@ var getCmd = &cobra.Command{
if err != nil {
return err
}
- resp, err := c.Get(cmd.Context(), types.Endpoints.Role(args[0]))
+ resp, err := c.Get(cmd.Context(), types.Role(args[0]))
if err != nil {
return errors.WrapIf(err, "failed to get role")
}
@@ -177,7 +177,7 @@ var createCmd = &cobra.Command{
req.Description = &roleCreateDescription
}
- resp, err := c.Post(cmd.Context(), types.Endpoints.Roles(), req)
+ resp, err := c.Post(cmd.Context(), types.Roles(), req)
if err != nil {
return errors.WrapIf(err, "failed to create role")
}
@@ -231,7 +231,7 @@ var updateCmd = &cobra.Command{
req.Permissions = roleUpdatePermissions
}
- resp, err := c.Put(cmd.Context(), types.Endpoints.Role(args[0]), req)
+ resp, err := c.Put(cmd.Context(), types.Role(args[0]), req)
if err != nil {
return errors.WrapIf(err, "failed to update role")
}
@@ -266,7 +266,7 @@ var deleteCmd = &cobra.Command{
if err != nil {
return err
}
- resp, err := c.Delete(cmd.Context(), types.Endpoints.Role(args[0]))
+ resp, err := c.Delete(cmd.Context(), types.Role(args[0]))
if err != nil {
return errors.WrapIf(err, "failed to delete role")
}
@@ -291,7 +291,7 @@ var permissionsCmd = &cobra.Command{
if err != nil {
return err
}
- resp, err := c.Get(cmd.Context(), types.Endpoints.RolesAvailablePermissions())
+ resp, err := c.Get(cmd.Context(), types.RolesAvailablePermissions())
if err != nil {
return errors.WrapIf(err, "failed to load permission manifest")
}
@@ -330,7 +330,7 @@ var assignmentsCmd = &cobra.Command{
if err != nil {
return err
}
- resp, err := c.Get(cmd.Context(), types.Endpoints.UserRoleAssignments(args[0]))
+ resp, err := c.Get(cmd.Context(), types.UserRoleAssignments(args[0]))
if err != nil {
return errors.WrapIf(err, "failed to list assignments")
}
@@ -385,7 +385,7 @@ var assignCmd = &cobra.Command{
if err != nil {
return err
}
- resp, err := c.Put(cmd.Context(), types.Endpoints.UserRoleAssignments(args[0]), req)
+ resp, err := c.Put(cmd.Context(), types.UserRoleAssignments(args[0]), req)
if err != nil {
return errors.WrapIf(err, "failed to set assignments")
}
@@ -432,7 +432,7 @@ func fetchRoleInternal(cmd *cobra.Command, id string) (*roletypes.Role, error) {
if err != nil {
return nil, err
}
- resp, err := c.Get(cmd.Context(), types.Endpoints.Role(id))
+ resp, err := c.Get(cmd.Context(), types.Role(id))
if err != nil {
return nil, errors.WrapIf(err, "failed to load current role")
}
diff --git a/cli/pkg/admin/users/cmd.go b/cli/pkg/admin/users/cmd.go
index 664c71036..91de57913 100644
--- a/cli/pkg/admin/users/cmd.go
+++ b/cli/pkg/admin/users/cmd.go
@@ -102,7 +102,7 @@ var listCmd = &cobra.Command{
return err
}
- path := types.Endpoints.Users()
+ path := types.Users()
path, err = cmdutil.ApplyPaginationParams(cmd, path, cmdutil.ListParams{Resource: "users", Limit: limitFlag, FallbackDefault: 20, Start: startFlag, All: allFlag})
if err != nil {
return errors.WrapIf(err, "failed to build pagination query")
@@ -188,7 +188,7 @@ var createCmd = &cobra.Command{
req.Email = &userCreateEmail
}
- resp, err := c.Post(cmd.Context(), types.Endpoints.Users(), req)
+ resp, err := c.Post(cmd.Context(), types.Users(), req)
if err != nil {
return errors.WrapIf(err, "failed to create user")
}
@@ -230,7 +230,7 @@ var getCmd = &cobra.Command{
return err
}
- resp, err := c.Get(cmd.Context(), types.Endpoints.User(args[0]))
+ resp, err := c.Get(cmd.Context(), types.User(args[0]))
if err != nil {
return errors.WrapIf(err, "failed to get user")
}
@@ -298,7 +298,7 @@ var updateCmd = &cobra.Command{
req.Email = &userUpdateEmail
}
- resp, err := c.Put(cmd.Context(), types.Endpoints.User(args[0]), req)
+ resp, err := c.Put(cmd.Context(), types.User(args[0]), req)
if err != nil {
return errors.WrapIf(err, "failed to update user")
}
@@ -345,7 +345,7 @@ var deleteCmd = &cobra.Command{
return err
}
- resp, err := c.Delete(cmd.Context(), types.Endpoints.User(args[0]))
+ resp, err := c.Delete(cmd.Context(), types.User(args[0]))
if err != nil {
return errors.WrapIf(err, "failed to delete user")
}
diff --git a/cli/pkg/auth/apikeys.go b/cli/pkg/auth/apikeys.go
new file mode 100644
index 000000000..c3d778ff8
--- /dev/null
+++ b/cli/pkg/auth/apikeys.go
@@ -0,0 +1,189 @@
+package auth
+
+import (
+ "fmt"
+ "time"
+
+ "emperror.dev/errors"
+
+ "github.com/getarcaneapp/arcane/cli/v2/internal/cmdutil"
+ "github.com/getarcaneapp/arcane/cli/v2/internal/output"
+ "github.com/getarcaneapp/arcane/cli/v2/internal/types"
+ apikeytypes "github.com/getarcaneapp/arcane/types/v2/apikey"
+ "github.com/getarcaneapp/arcane/types/v2/base"
+ "github.com/spf13/cobra"
+)
+
+var (
+ apiKeyForceFlag bool
+ apiKeyCreateDescription string
+ apiKeyCreateExpiresAt string
+)
+
+// apiKeysCmd is the parent command for the caller's own (personal) API keys.
+// Personal keys inherit the owner's role permissions; scoped keys with
+// granular grants are managed via `arcane admin apikeys`.
+var apiKeysCmd = &cobra.Command{
+ Use: "keys",
+ Aliases: []string{"apikeys", "key"},
+ Short: "Manage your own API keys",
+ Long: "Manage the current user's personal API keys. Personal keys inherit " +
+ "the owner's role permissions. Creating and deleting them requires a " +
+ "session login (an API key cannot mint or remove other keys).",
+}
+
+var apiKeysListCmd = &cobra.Command{
+ Use: "list",
+ Aliases: []string{"ls"},
+ Short: "List your API keys",
+ SilenceUsage: true,
+ RunE: func(cmd *cobra.Command, args []string) error {
+ c, err := cmdutil.ClientFromCommand(cmd)
+ if err != nil {
+ return err
+ }
+
+ resp, err := c.Get(cmd.Context(), types.AuthMeApiKeys())
+ if err != nil {
+ return errors.WrapIf(err, "failed to list API keys")
+ }
+ defer func() { _ = resp.Body.Close() }()
+
+ var result base.ApiResponse[[]apikeytypes.ApiKey]
+ if err := cmdutil.DecodeJSON(resp, &result); err != nil {
+ return errors.WrapIf(err, "failed to list API keys")
+ }
+
+ if cmdutil.JSONOutputEnabled(cmd) || jsonOutput {
+ return cmdutil.PrintJSON(result.Data)
+ }
+
+ if len(result.Data) == 0 {
+ output.Info("No API keys found")
+ return nil
+ }
+
+ headers := []string{"ID", "NAME", "KIND", "PREFIX", "EXPIRES", "LAST USED", "CREATED"}
+ rows := make([][]string, len(result.Data))
+ for i, key := range result.Data {
+ expires := "never"
+ if key.ExpiresAt != nil {
+ expires = key.ExpiresAt.Format("2006-01-02 15:04")
+ }
+ lastUsed := "never"
+ if key.LastUsedAt != nil {
+ lastUsed = key.LastUsedAt.Format("2006-01-02 15:04")
+ }
+ rows[i] = []string{
+ key.ID,
+ key.Name,
+ key.Kind,
+ key.KeyPrefix,
+ expires,
+ lastUsed,
+ key.CreatedAt.Format("2006-01-02 15:04"),
+ }
+ }
+ output.Table(headers, rows)
+ return nil
+ },
+}
+
+var apiKeysCreateCmd = &cobra.Command{
+ Use: "create <name>",
+ Short: "Create a personal API key",
+ Args: cobra.ExactArgs(1),
+ SilenceUsage: true,
+ RunE: func(cmd *cobra.Command, args []string) error {
+ c, err := cmdutil.ClientFromCommand(cmd)
+ if err != nil {
+ return err
+ }
+
+ req := apikeytypes.CreateUserApiKey{Name: args[0]}
+ if cmd.Flags().Changed("description") {
+ req.Description = &apiKeyCreateDescription
+ }
+ if apiKeyCreateExpiresAt != "" {
+ parsed, err := time.Parse(time.RFC3339, apiKeyCreateExpiresAt)
+ if err != nil {
+ return errors.WrapIf(err, "invalid --expires-at format (use RFC3339)")
+ }
+ req.ExpiresAt = &parsed
+ }
+
+ resp, err := c.Post(cmd.Context(), types.AuthMeApiKeys(), req)
+ if err != nil {
+ return errors.WrapIf(err, "failed to create API key")
+ }
+ defer func() { _ = resp.Body.Close() }()
+
+ var result base.ApiResponse[apikeytypes.ApiKeyCreatedDto]
+ if err := cmdutil.DecodeJSON(resp, &result); err != nil {
+ return errors.WrapIf(err, "failed to create API key")
+ }
+
+ if cmdutil.JSONOutputEnabled(cmd) || jsonOutput {
+ return cmdutil.PrintJSON(result.Data)
+ }
+
+ output.Success("API key created")
+ output.KeyValue("ID", result.Data.ID)
+ output.KeyValue("Name", result.Data.Name)
+ output.Warning("The key secret is shown only once — store it now:")
+ output.KeyValue("Key", result.Data.Key)
+ return nil
+ },
+}
+
+var apiKeysDeleteCmd = &cobra.Command{
+ Use: "delete <id>",
+ Aliases: []string{"rm", "remove"},
+ Short: "Delete one of your API keys",
+ Args: cobra.ExactArgs(1),
+ SilenceUsage: true,
+ RunE: func(cmd *cobra.Command, args []string) error {
+ if !apiKeyForceFlag {
+ confirmed, err := cmdutil.Confirm(cmd, fmt.Sprintf("Are you sure you want to delete API key %s?", args[0]))
+ if err != nil {
+ return err
+ }
+ if !confirmed {
+ fmt.Println("Cancelled")
+ return nil
+ }
+ }
+
+ c, err := cmdutil.ClientFromCommand(cmd)
+ if err != nil {
+ return err
+ }
+
+ resp, err := c.Delete(cmd.Context(), types.AuthMeApiKey(args[0]))
+ if err != nil {
+ return errors.WrapIf(err, "failed to delete API key")
+ }
+ defer func() { _ = resp.Body.Close() }()
+ if err := cmdutil.EnsureSuccessStatus(resp); err != nil {
+ return errors.WrapIf(err, "failed to delete API key")
+ }
+
+ output.Success("API key deleted")
+ return nil
+ },
+}
+
+func init() {
+ AuthCmd.AddCommand(apiKeysCmd)
+ apiKeysCmd.AddCommand(apiKeysListCmd)
+ apiKeysCmd.AddCommand(apiKeysCreateCmd)
+ apiKeysCmd.AddCommand(apiKeysDeleteCmd)
+
+ apiKeysListCmd.Flags().BoolVar(&jsonOutput, "json", false, "Output in JSON format")
+
+ apiKeysCreateCmd.Flags().StringVar(&apiKeyCreateDescription, "description", "", "Description of the API key")
+ apiKeysCreateCmd.Flags().StringVar(&apiKeyCreateExpiresAt, "expires-at", "", "Expiration date (RFC3339 format)")
+ apiKeysCreateCmd.Flags().BoolVar(&jsonOutput, "json", false, "Output in JSON format")
+
+ apiKeysDeleteCmd.Flags().BoolVarP(&apiKeyForceFlag, "force", "f", false, "Force deletion without confirmation")
+}
diff --git a/cli/pkg/auth/cmd.go b/cli/pkg/auth/cmd.go
index f462727f7..25add9337 100644
--- a/cli/pkg/auth/cmd.go
+++ b/cli/pkg/auth/cmd.go
@@ -45,7 +45,7 @@ var loginCmd = &cobra.Command{
return errors.WrapIf(err, "failed to marshal request")
}
- resp, err := c.Post(cmd.Context(), types.Endpoints.OIDCDeviceCode(), reqBody)
+ resp, err := c.Post(cmd.Context(), types.OIDCDeviceCode(), reqBody)
if err != nil {
return errors.WrapIf(err, "device authorization failed")
}
@@ -98,7 +98,7 @@ var loginCmd = &cobra.Command{
return cmd.Context().Err()
}
- tokenResp, err := c.Post(cmd.Context(), types.Endpoints.OIDCDeviceToken(), tokenReqBody)
+ tokenResp, err := c.Post(cmd.Context(), types.OIDCDeviceToken(), tokenReqBody)
if err != nil {
return errors.WrapIf(err, "device token exchange failed")
}
@@ -181,7 +181,7 @@ var logoutCmd = &cobra.Command{
return err
}
- resp, err := c.Post(cmd.Context(), types.Endpoints.AuthLogout(), nil)
+ resp, err := c.Post(cmd.Context(), types.AuthLogout(), nil)
if err != nil {
return errors.WrapIf(err, "logout failed")
}
@@ -228,7 +228,7 @@ var meCmd = &cobra.Command{
return err
}
- resp, err := c.Get(cmd.Context(), types.Endpoints.AuthMe())
+ resp, err := c.Get(cmd.Context(), types.AuthMe())
if err != nil {
return errors.WrapIf(err, "failed to get user info")
}
@@ -304,7 +304,7 @@ var passwordCmd = &cobra.Command{
return errors.WrapIf(err, "failed to marshal request")
}
- resp, err := c.Post(cmd.Context(), types.Endpoints.AuthPassword(), reqBody)
+ resp, err := c.Post(cmd.Context(), types.AuthPassword(), reqBody)
if err != nil {
return errors.WrapIf(err, "password change failed")
}
@@ -360,7 +360,7 @@ var refreshCmd = &cobra.Command{
return errors.WrapIf(err, "failed to marshal request")
}
- resp, err := c.Post(cmd.Context(), types.Endpoints.AuthRefresh(), reqBody)
+ resp, err := c.Post(cmd.Context(), types.AuthRefresh(), reqBody)
if err != nil {
return errors.WrapIf(err, "token refresh failed")
}
@@ -405,7 +405,8 @@ var refreshCmd = &cobra.Command{
}
var oidcStatusCmd = &cobra.Command{
- Use: "oidc-status",
+ Use: "oidc",
+ Aliases: []string{"oidc-status"},
Short: "Show OIDC configuration status",
SilenceUsage: true,
RunE: func(cmd *cobra.Command, args []string) error {
@@ -414,7 +415,7 @@ var oidcStatusCmd = &cobra.Command{
return err
}
- resp, err := c.Get(cmd.Context(), types.Endpoints.OIDCStatus())
+ resp, err := c.Get(cmd.Context(), types.OIDCStatus())
if err != nil {
return errors.WrapIf(err, "failed to get OIDC status")
}
diff --git a/cli/pkg/auth/federated.go b/cli/pkg/auth/federated.go
index 5f371d3c8..8399765a7 100644
--- a/cli/pkg/auth/federated.go
+++ b/cli/pkg/auth/federated.go
@@ -182,7 +182,7 @@ func exchangeFederatedTokenInternal(cmd *cobra.Command, c *client.Client, subjec
form.Set("audience", strings.TrimSpace(audience))
}
- resp, err := c.RequestRaw(cmd.Context(), http.MethodPost, types.Endpoints.AuthFederated(), strings.NewReader(form.Encode()), map[string]string{
+ resp, err := c.RequestRaw(cmd.Context(), http.MethodPost, types.AuthFederated(), strings.NewReader(form.Encode()), map[string]string{
"Content-Type": "application/x-www-form-urlencoded",
})
if err != nil {
diff --git a/cli/pkg/backups/cmd.go b/cli/pkg/backups/cmd.go
new file mode 100644
index 000000000..6bcf9808f
--- /dev/null
+++ b/cli/pkg/backups/cmd.go
@@ -0,0 +1,839 @@
+package backups
+
+import (
+ "encoding/json"
+ "fmt"
+ "io"
+ "os"
+ "strconv"
+
+ "emperror.dev/errors"
+
+ "github.com/charmbracelet/x/term"
+ "github.com/getarcaneapp/arcane/cli/v2/internal/client"
+ "github.com/getarcaneapp/arcane/cli/v2/internal/cmdutil"
+ "github.com/getarcaneapp/arcane/cli/v2/internal/output"
+ "github.com/getarcaneapp/arcane/cli/v2/internal/prompt"
+ "github.com/getarcaneapp/arcane/cli/v2/internal/types"
+ "github.com/getarcaneapp/arcane/types/v2/backup"
+ "github.com/getarcaneapp/arcane/types/v2/base"
+ "github.com/spf13/cobra"
+)
+
+var (
+ limitFlag int
+ startFlag int
+ allFlag bool
+ forceFlag bool
+ jsonOutput bool
+
+ createDestination string
+ createS3Destination string
+ createLocal bool
+ createRecoveryKey string
+ createPolicyID string
+
+ deleteRecoveryKey string
+
+ restoreRecoveryKey string
+
+ uploadS3Destination string
+ uploadRecoveryKey string
+
+ discoverS3Destination string
+ discoverRecoveryKey string
+
+ policiesUpdateFile string
+ policiesUpdateID string
+ policiesUpdateEnabled bool
+ policiesUpdateDisabled bool
+ policiesUpdateSchedule string
+ policiesUpdateRetention int
+ policiesUpdateLocal bool
+ policiesUpdateS3 bool
+ policiesUpdateS3Destination string
+
+ generateSave bool
+ setRecoveryKey string
+)
+
+// BackupsCmd is the parent command for Arcane system backup operations (admin-only).
+var BackupsCmd = &cobra.Command{
+ Use: "backups",
+ Aliases: []string{"backup"},
+ Short: "Manage Arcane system backups (admin only)",
+ Long: `System backups snapshot Arcane's database and configuration, encrypted with the recovery key.
+Backups are stored in the local repository, a saved S3 destination, or both; policies schedule automatic runs.`,
+}
+
+var listCmd = &cobra.Command{
+ Use: "list",
+ Aliases: []string{"ls"},
+ Short: "List Arcane system backups",
+ SilenceUsage: true,
+ RunE: func(cmd *cobra.Command, args []string) error {
+ c, err := cmdutil.ClientFromCommand(cmd)
+ if err != nil {
+ return err
+ }
+
+ path, err := cmdutil.ApplyPaginationParams(cmd, types.Backups(), cmdutil.ListParams{
+ Resource: "backups",
+ Limit: limitFlag,
+ FallbackDefault: 20,
+ Start: startFlag,
+ All: allFlag,
+ })
+ if err != nil {
+ return errors.WrapIf(err, "failed to build pagination query")
+ }
+
+ resp, err := c.Get(cmd.Context(), path)
+ if err != nil {
+ return errors.WrapIf(err, "failed to list backups")
+ }
+ defer func() { _ = resp.Body.Close() }()
+
+ body, err := cmdutil.ReadJSONBody(resp)
+ if err != nil {
+ return errors.WrapIf(err, "failed to list backups")
+ }
+
+ if cmdutil.JSONOutputEnabled(cmd) {
+ return cmdutil.PrintRawJSON(body)
+ }
+
+ var result base.Paginated[backup.SystemBackupRun]
+ if err := json.Unmarshal(body, &result); err != nil {
+ return errors.WrapIf(err, "failed to parse response")
+ }
+
+ headers := []string{"ID", "STATUS", "TRIGGER", "DESTINATION", "SIZE", "S3 DESTINATION", "CREATED"}
+ rows := make([][]string, len(result.Data))
+ for i, run := range result.Data {
+ size := ""
+ if run.Size > 0 {
+ size = output.Bytes(run.Size)
+ }
+ rows[i] = []string{
+ run.ID,
+ run.Status,
+ run.Trigger,
+ string(run.Destination),
+ size,
+ run.S3DestinationName,
+ run.CreatedAt.Format("2006-01-02 15:04"),
+ }
+ }
+
+ output.Table(headers, rows)
+ output.Showing(len(result.Data), result.Pagination.TotalItems, "backups")
+ return nil
+ },
+}
+
+var createCmd = &cobra.Command{
+ Use: "create",
+ Short: "Create an Arcane system backup",
+ Long: `Create a system backup. With no flags the backup is stored locally; --s3-destination
+alone stores it in S3, and --local together with --s3-destination stores it in both.`,
+ Args: cobra.NoArgs,
+ SilenceUsage: true,
+ RunE: func(cmd *cobra.Command, args []string) error {
+ c, err := cmdutil.ClientFromCommand(cmd)
+ if err != nil {
+ return err
+ }
+
+ s3DestinationID := ""
+ if createS3Destination != "" {
+ resolved, err := resolveS3Destination(cmd.Context(), c, createS3Destination, !cmdutil.JSONOutputEnabled(cmd))
+ if err != nil {
+ return err
+ }
+ s3DestinationID = resolved.ID
+ }
+
+ destination := backup.SystemBackupDestination(createDestination)
+ if cmd.Flags().Changed("destination") {
+ switch destination {
+ case backup.SystemBackupDestinationLocal, backup.SystemBackupDestinationS3, backup.SystemBackupDestinationLocalS3:
+ default:
+ return errors.Errorf("invalid --destination %q: must be local, s3, or local_s3", createDestination)
+ }
+ } else {
+ switch {
+ case s3DestinationID != "" && createLocal:
+ destination = backup.SystemBackupDestinationLocalS3
+ case s3DestinationID != "":
+ destination = backup.SystemBackupDestinationS3
+ default:
+ destination = backup.SystemBackupDestinationLocal
+ }
+ }
+ if (destination == backup.SystemBackupDestinationS3 || destination == backup.SystemBackupDestinationLocalS3) && s3DestinationID == "" {
+ return errors.Errorf("--destination %s requires --s3-destination", destination)
+ }
+
+ req := backup.CreateSystemBackupRequest{
+ Destination: destination,
+ S3DestinationID: s3DestinationID,
+ RecoveryKey: createRecoveryKey,
+ PolicyID: createPolicyID,
+ }
+
+ resp, err := c.Post(cmd.Context(), types.Backups(), req)
+ if err != nil {
+ return errors.WrapIf(err, "failed to create backup")
+ }
+ defer func() { _ = resp.Body.Close() }()
+ if err := cmdutil.EnsureSuccessStatus(resp); err != nil {
+ return errors.WrapIf(err, "failed to create backup")
+ }
+
+ body, err := cmdutil.ReadJSONBody(resp)
+ if err != nil {
+ return errors.WrapIf(err, "failed to create backup")
+ }
+
+ if cmdutil.JSONOutputEnabled(cmd) {
+ return cmdutil.PrintRawJSON(body)
+ }
+
+ var run backup.SystemBackupRun
+ if err := json.Unmarshal(body, &run); err != nil {
+ return errors.WrapIf(err, "failed to parse response")
+ }
+
+ output.Success("Backup %s created successfully", run.ID)
+ output.KeyValue("ID", run.ID)
+ output.KeyValue("Status", run.Status)
+ output.KeyValue("Destination", string(run.Destination))
+ if run.Size > 0 {
+ output.KeyValue("Size", output.Bytes(run.Size))
+ }
+ if run.S3DestinationName != "" {
+ output.KeyValue("S3 Destination", run.S3DestinationName)
+ }
+ return nil
+ },
+}
+
+var deleteCmd = &cobra.Command{
+ Use: "delete <backup-id>",
+ Aliases: []string{"rm", "remove"},
+ Short: "Delete an Arcane system backup",
+ Args: cobra.ExactArgs(1),
+ SilenceUsage: true,
+ RunE: func(cmd *cobra.Command, args []string) error {
+ if !forceFlag {
+ confirmed, err := cmdutil.Confirm(cmd, fmt.Sprintf("Are you sure you want to delete backup %s?", args[0]))
+ if err != nil {
+ return err
+ }
+ if !confirmed {
+ fmt.Println("Cancelled")
+ return nil
+ }
+ }
+
+ c, err := cmdutil.ClientFromCommand(cmd)
+ if err != nil {
+ return err
+ }
+
+ resp, err := c.DeleteWithBody(cmd.Context(), types.Backup(args[0]), backup.DeleteSystemBackupRequest{RecoveryKey: deleteRecoveryKey})
+ if err != nil {
+ return errors.WrapIf(err, "failed to delete backup")
+ }
+ defer func() { _ = resp.Body.Close() }()
+ if err := cmdutil.EnsureSuccessStatus(resp); err != nil {
+ return errors.WrapIf(err, "failed to delete backup")
+ }
+
+ if cmdutil.JSONOutputEnabled(cmd) {
+ body, err := cmdutil.ReadJSONBody(resp)
+ if err != nil {
+ return errors.WrapIf(err, "failed to delete backup")
+ }
+ return cmdutil.PrintRawJSON(body)
+ }
+
+ output.Success("Backup %s deleted successfully", args[0])
+ return nil
+ },
+}
+
+var restoreCmd = &cobra.Command{
+ Use: "restore <backup-id>",
+ Short: "Restore Arcane from a system backup",
+ Long: `Restore overwrites the current Arcane database and configuration with the backup contents, then restarts Arcane.`,
+ Args: cobra.ExactArgs(1),
+ SilenceUsage: true,
+ RunE: func(cmd *cobra.Command, args []string) error {
+ if !forceFlag {
+ output.Warning("Restoring backup %s will OVERWRITE the current Arcane database and configuration, then restart Arcane. This cannot be undone.", args[0])
+ confirmed, err := cmdutil.Confirm(cmd, "Are you absolutely sure you want to restore this backup?")
+ if err != nil {
+ return err
+ }
+ if !confirmed {
+ fmt.Println("Cancelled")
+ return nil
+ }
+ }
+
+ key := restoreRecoveryKey
+ if key == "" {
+ if !prompt.IsInteractive() {
+ return errors.New("recovery key is required; pass --recovery-key")
+ }
+ fmt.Print("Recovery key: ")
+ byteKey, err := term.ReadPassword(os.Stdin.Fd())
+ if err != nil {
+ return errors.WrapIf(err, "failed to read recovery key")
+ }
+ key = string(byteKey)
+ fmt.Println()
+ if key == "" {
+ return errors.New("recovery key is required")
+ }
+ }
+
+ c, err := cmdutil.ClientFromCommand(cmd)
+ if err != nil {
+ return err
+ }
+
+ resp, err := c.Post(cmd.Context(), types.BackupRestore(args[0]), backup.RestoreSystemBackupRequest{RecoveryKey: key})
+ if err != nil {
+ return errors.WrapIf(err, "failed to restore backup")
+ }
+ defer func() { _ = resp.Body.Close() }()
+ if err := cmdutil.EnsureSuccessStatus(resp); err != nil {
+ return errors.WrapIf(err, "failed to restore backup")
+ }
+
+ body, err := cmdutil.ReadJSONBody(resp)
+ if err != nil {
+ return errors.WrapIf(err, "failed to restore backup")
+ }
+
+ if cmdutil.JSONOutputEnabled(cmd) {
+ return cmdutil.PrintRawJSON(body)
+ }
+
+ var result base.ApiResponse[base.MessageResponse]
+ if err := json.Unmarshal(body, &result); err != nil {
+ return errors.WrapIf(err, "failed to parse response")
+ }
+
+ output.Success("%s", result.Data.Message)
+ output.Warning("Arcane will restart while the restore is applied; the server may be unavailable for a short time.")
+ return nil
+ },
+}
+
+var uploadCmd = &cobra.Command{
+ Use: "upload <backup-id>",
+ Short: "Upload an Arcane system backup to an S3 destination",
+ Args: cobra.ExactArgs(1),
+ SilenceUsage: true,
+ RunE: func(cmd *cobra.Command, args []string) error {
+ c, err := cmdutil.ClientFromCommand(cmd)
+ if err != nil {
+ return err
+ }
+
+ resolved, err := resolveS3Destination(cmd.Context(), c, uploadS3Destination, !cmdutil.JSONOutputEnabled(cmd))
+ if err != nil {
+ return err
+ }
+
+ req := backup.UploadSystemBackupRequest{
+ S3DestinationID: resolved.ID,
+ RecoveryKey: uploadRecoveryKey,
+ }
+
+ resp, err := c.Post(cmd.Context(), types.BackupUpload(args[0]), req)
+ if err != nil {
+ return errors.WrapIf(err, "failed to upload backup")
+ }
+ defer func() { _ = resp.Body.Close() }()
+ if err := cmdutil.EnsureSuccessStatus(resp); err != nil {
+ return errors.WrapIf(err, "failed to upload backup")
+ }
+
+ body, err := cmdutil.ReadJSONBody(resp)
+ if err != nil {
+ return errors.WrapIf(err, "failed to upload backup")
+ }
+
+ if cmdutil.JSONOutputEnabled(cmd) {
+ return cmdutil.PrintRawJSON(body)
+ }
+
+ var run backup.SystemBackupRun
+ if err := json.Unmarshal(body, &run); err != nil {
+ return errors.WrapIf(err, "failed to parse response")
+ }
+
+ output.Success("Backup %s uploaded successfully", run.ID)
+ output.KeyValue("Destination", string(run.Destination))
+ if run.S3DestinationName != "" {
+ output.KeyValue("S3 Destination", run.S3DestinationName)
+ }
+ return nil
+ },
+}
+
+var discoverCmd = &cobra.Command{
+ Use: "discover",
+ Short: "Discover Arcane system backups stored in an S3 destination",
+ Long: `Discover scans an S3 destination for backups and imports records for any not already known to this Arcane instance.`,
+ Args: cobra.NoArgs,
+ SilenceUsage: true,
+ RunE: func(cmd *cobra.Command, args []string) error {
+ c, err := cmdutil.ClientFromCommand(cmd)
+ if err != nil {
+ return err
+ }
+
+ resolved, err := resolveS3Destination(cmd.Context(), c, discoverS3Destination, !cmdutil.JSONOutputEnabled(cmd))
+ if err != nil {
+ return err
+ }
+
+ req := backup.DiscoverSystemBackupsRequest{
+ S3DestinationID: resolved.ID,
+ RecoveryKey: discoverRecoveryKey,
+ }
+
+ resp, err := c.Post(cmd.Context(), types.BackupsDiscover(), req)
+ if err != nil {
+ return errors.WrapIf(err, "failed to discover backups")
+ }
+ defer func() { _ = resp.Body.Close() }()
+ if err := cmdutil.EnsureSuccessStatus(resp); err != nil {
+ return errors.WrapIf(err, "failed to discover backups")
+ }
+
+ body, err := cmdutil.ReadJSONBody(resp)
+ if err != nil {
+ return errors.WrapIf(err, "failed to discover backups")
+ }
+
+ if cmdutil.JSONOutputEnabled(cmd) {
+ return cmdutil.PrintRawJSON(body)
+ }
+
+ var result base.ApiResponse[int]
+ if err := json.Unmarshal(body, &result); err != nil {
+ return errors.WrapIf(err, "failed to parse response")
+ }
+
+ output.Success("Discovered %d backup(s)", result.Data)
+ return nil
+ },
+}
+
+var policiesCmd = &cobra.Command{
+ Use: "policies",
+ Short: "Show Arcane system backup policies",
+ Args: cobra.NoArgs,
+ SilenceUsage: true,
+ RunE: func(cmd *cobra.Command, args []string) error {
+ c, err := cmdutil.ClientFromCommand(cmd)
+ if err != nil {
+ return err
+ }
+
+ resp, err := c.Get(cmd.Context(), types.BackupsPolicies())
+ if err != nil {
+ return errors.WrapIf(err, "failed to get backup policies")
+ }
+ defer func() { _ = resp.Body.Close() }()
+
+ body, err := cmdutil.ReadJSONBody(resp)
+ if err != nil {
+ return errors.WrapIf(err, "failed to get backup policies")
+ }
+
+ if cmdutil.JSONOutputEnabled(cmd) {
+ return cmdutil.PrintRawJSON(body)
+ }
+
+ var result backup.SystemBackupPolicyCollection
+ if err := json.Unmarshal(body, &result); err != nil {
+ return errors.WrapIf(err, "failed to parse response")
+ }
+
+ printPolicies(result)
+ return nil
+ },
+}
+
+func printPolicies(result backup.SystemBackupPolicyCollection) {
+ output.Header("System Backup Policies")
+ recoveryKey := "Not configured"
+ if result.RecoveryKeyStored {
+ recoveryKey = "Configured"
+ }
+ output.KeyValue("Recovery Key", recoveryKey)
+
+ headers := []string{"ID", "ENABLED", "SCHEDULE", "RETENTION", "LOCAL", "S3", "S3 DESTINATION", "LAST RUN"}
+ rows := make([][]string, len(result.Policies))
+ for i, policy := range result.Policies {
+ lastRun := ""
+ if policy.LastRun != nil {
+ lastRun = fmt.Sprintf("%s (%s)", policy.LastRun.CreatedAt.Format("2006-01-02 15:04"), policy.LastRun.Status)
+ }
+ rows[i] = []string{
+ policy.ID,
+ strconv.FormatBool(policy.Enabled),
+ policy.Schedule,
+ strconv.Itoa(policy.RetentionCount),
+ strconv.FormatBool(policy.LocalEnabled),
+ strconv.FormatBool(policy.S3Enabled),
+ policy.S3DestinationName,
+ lastRun,
+ }
+ }
+ output.Table(headers, rows)
+}
+
+var policiesUpdateCmd = &cobra.Command{
+ Use: "update",
+ Short: "Update Arcane system backup policies",
+ Long: `Update a system backup policy with flags: the current policies are fetched, the targeted
+policy is modified, and the whole set is saved back. A new policy is created when none exist.
+Alternatively, --file replaces all policies from a raw JSON payload.`,
+ Args: cobra.NoArgs,
+ SilenceUsage: true,
+ RunE: func(cmd *cobra.Command, args []string) error {
+ c, err := cmdutil.ClientFromCommand(cmd)
+ if err != nil {
+ return err
+ }
+
+ var req backup.UpdateSystemBackupPolicies
+ if policiesUpdateFile != "" {
+ for _, name := range []string{"policy-id", "enabled", "disabled", "schedule", "retention", "local", "s3", "s3-destination"} {
+ if cmd.Flags().Changed(name) {
+ return errors.Errorf("--file cannot be combined with --%s", name)
+ }
+ }
+
+ var data []byte
+ if policiesUpdateFile == "-" {
+ data, err = io.ReadAll(os.Stdin)
+ if err != nil {
+ return errors.WrapIf(err, "failed to read policies from stdin")
+ }
+ } else {
+ data, err = os.ReadFile(policiesUpdateFile)
+ if err != nil {
+ return errors.WrapIff(err, "failed to read file %s", policiesUpdateFile)
+ }
+ }
+ if err := json.Unmarshal(data, &req); err != nil {
+ return errors.WrapIf(err, "failed to parse policies file")
+ }
+ } else {
+ currentResp, err := c.Get(cmd.Context(), types.BackupsPolicies())
+ if err != nil {
+ return errors.WrapIf(err, "failed to get current backup policies")
+ }
+ defer func() { _ = currentResp.Body.Close() }()
+ if err := cmdutil.EnsureSuccessStatus(currentResp); err != nil {
+ return errors.WrapIf(err, "failed to get current backup policies")
+ }
+
+ var current backup.SystemBackupPolicyCollection
+ if err := cmdutil.DecodeJSON(currentResp, &current); err != nil {
+ return err
+ }
+
+ req.Policies = make([]backup.UpdateSystemBackupPolicy, len(current.Policies))
+ targetIndex := -1
+ for i, p := range current.Policies {
+ req.Policies[i] = backup.UpdateSystemBackupPolicy{
+ ID: p.ID,
+ Enabled: p.Enabled,
+ Schedule: p.Schedule,
+ RetentionCount: p.RetentionCount,
+ LocalEnabled: p.LocalEnabled,
+ S3Enabled: p.S3Enabled,
+ S3DestinationID: p.S3DestinationID,
+ }
+ if policiesUpdateID != "" && p.ID == policiesUpdateID {
+ targetIndex = i
+ }
+ }
+
+ switch {
+ case policiesUpdateID != "" && targetIndex == -1:
+ return errors.Errorf("policy %q not found; run `arcane backups policies`", policiesUpdateID)
+ case policiesUpdateID == "" && len(req.Policies) > 1:
+ return errors.Errorf("%d backup policies exist; select one with --policy-id", len(req.Policies))
+ case policiesUpdateID == "" && len(req.Policies) == 1:
+ targetIndex = 0
+ case targetIndex == -1:
+ if !cmd.Flags().Changed("schedule") {
+ return errors.New("--schedule is required when creating a new backup policy")
+ }
+ // New policies default to local storage unless --local was set explicitly.
+ req.Policies = append(req.Policies, backup.UpdateSystemBackupPolicy{LocalEnabled: !cmd.Flags().Changed("local") || policiesUpdateLocal})
+ targetIndex = len(req.Policies) - 1
+ }
+
+ target := &req.Policies[targetIndex]
+ if cmd.Flags().Changed("enabled") {
+ target.Enabled = true
+ }
+ if cmd.Flags().Changed("disabled") {
+ target.Enabled = false
+ }
+ if cmd.Flags().Changed("schedule") {
+ target.Schedule = policiesUpdateSchedule
+ }
+ if cmd.Flags().Changed("retention") {
+ target.RetentionCount = policiesUpdateRetention
+ }
+ if cmd.Flags().Changed("local") {
+ target.LocalEnabled = policiesUpdateLocal
+ }
+ if cmd.Flags().Changed("s3") {
+ target.S3Enabled = policiesUpdateS3
+ }
+ if cmd.Flags().Changed("s3-destination") {
+ resolved, err := resolveS3Destination(cmd.Context(), c, policiesUpdateS3Destination, !cmdutil.JSONOutputEnabled(cmd))
+ if err != nil {
+ return err
+ }
+ target.S3DestinationID = resolved.ID
+ if !cmd.Flags().Changed("s3") {
+ target.S3Enabled = true
+ }
+ }
+ }
+
+ resp, err := c.Put(cmd.Context(), types.BackupsPolicies(), req)
+ if err != nil {
+ return errors.WrapIf(err, "failed to update backup policies")
+ }
+ defer func() { _ = resp.Body.Close() }()
+ if err := cmdutil.EnsureSuccessStatus(resp); err != nil {
+ return errors.WrapIf(err, "failed to update backup policies")
+ }
+
+ body, err := cmdutil.ReadJSONBody(resp)
+ if err != nil {
+ return errors.WrapIf(err, "failed to update backup policies")
+ }
+
+ if cmdutil.JSONOutputEnabled(cmd) {
+ return cmdutil.PrintRawJSON(body)
+ }
+
+ var result backup.SystemBackupPolicyCollection
+ if err := json.Unmarshal(body, &result); err != nil {
+ return errors.WrapIf(err, "failed to parse response")
+ }
+
+ output.Success("Backup policies updated successfully")
+ printPolicies(result)
+ return nil
+ },
+}
+
+var recoveryKeyCmd = &cobra.Command{
+ Use: "recovery",
+ Short: "Manage the Arcane system backup recovery key",
+}
+
+var recoveryKeyGenerateCmd = &cobra.Command{
+ Use: "generate",
+ Short: "Generate a new Arcane system backup recovery key",
+ Args: cobra.NoArgs,
+ SilenceUsage: true,
+ RunE: func(cmd *cobra.Command, args []string) error {
+ c, err := cmdutil.ClientFromCommand(cmd)
+ if err != nil {
+ return err
+ }
+
+ resp, err := c.Post(cmd.Context(), types.BackupsRecoveryKeyGenerate(), nil)
+ if err != nil {
+ return errors.WrapIf(err, "failed to generate recovery key")
+ }
+ defer func() { _ = resp.Body.Close() }()
+ if err := cmdutil.EnsureSuccessStatus(resp); err != nil {
+ return errors.WrapIf(err, "failed to generate recovery key")
+ }
+
+ body, err := cmdutil.ReadJSONBody(resp)
+ if err != nil {
+ return errors.WrapIf(err, "failed to generate recovery key")
+ }
+
+ var result backup.SystemBackupRecoveryKey
+ if err := json.Unmarshal(body, &result); err != nil {
+ return errors.WrapIf(err, "failed to parse response")
+ }
+
+ if cmdutil.JSONOutputEnabled(cmd) {
+ if generateSave {
+ if err := storeRecoveryKey(cmd, c, result.RecoveryKey); err != nil {
+ return err
+ }
+ }
+ return cmdutil.PrintRawJSON(body)
+ }
+
+ output.Header("Generated Recovery Key")
+ fmt.Println(result.RecoveryKey)
+ output.Warning("Store this recovery key somewhere safe. Backups encrypted with it cannot be restored without it.")
+
+ save := generateSave
+ if !save && prompt.IsInteractive() {
+ save, err = cmdutil.Confirm(cmd, "Store this recovery key on the server now?")
+ if err != nil {
+ return err
+ }
+ }
+ if !save {
+ fmt.Println("Run `arcane backups recovery set` to store it on the server later.")
+ return nil
+ }
+ if err := storeRecoveryKey(cmd, c, result.RecoveryKey); err != nil {
+ return err
+ }
+ output.Success("Recovery key stored on the server")
+ return nil
+ },
+}
+
+var recoveryKeySetCmd = &cobra.Command{
+ Use: "set",
+ Short: "Configure the Arcane system backup recovery key",
+ Args: cobra.NoArgs,
+ SilenceUsage: true,
+ RunE: func(cmd *cobra.Command, args []string) error {
+ key := setRecoveryKey
+ if key == "" {
+ if !prompt.IsInteractive() {
+ return errors.New("recovery key is required; pass --recovery-key")
+ }
+ fmt.Print("Recovery key: ")
+ byteKey, err := term.ReadPassword(os.Stdin.Fd())
+ if err != nil {
+ return errors.WrapIf(err, "failed to read recovery key")
+ }
+ key = string(byteKey)
+ fmt.Println()
+ }
+ if key == "" {
+ return errors.New("recovery key is required; use --recovery-key")
+ }
+
+ c, err := cmdutil.ClientFromCommand(cmd)
+ if err != nil {
+ return err
+ }
+
+ resp, err := c.Put(cmd.Context(), types.BackupsRecoveryKey(), backup.SystemBackupRecoveryKey{RecoveryKey: key})
+ if err != nil {
+ return errors.WrapIf(err, "failed to set recovery key")
+ }
+ defer func() { _ = resp.Body.Close() }()
+ if err := cmdutil.EnsureSuccessStatus(resp); err != nil {
+ return errors.WrapIf(err, "failed to set recovery key")
+ }
+
+ if cmdutil.JSONOutputEnabled(cmd) {
+ body, err := cmdutil.ReadJSONBody(resp)
+ if err != nil {
+ return errors.WrapIf(err, "failed to set recovery key")
+ }
+ return cmdutil.PrintRawJSON(body)
+ }
+
+ output.Success("Recovery key configured successfully")
+ return nil
+ },
+}
+
+func storeRecoveryKey(cmd *cobra.Command, c *client.Client, key string) error {
+ resp, err := c.Put(cmd.Context(), types.BackupsRecoveryKey(), backup.SystemBackupRecoveryKey{RecoveryKey: key})
+ if err != nil {
+ return errors.WrapIf(err, "failed to store recovery key")
+ }
+ defer func() { _ = resp.Body.Close() }()
+ return errors.WrapIf(cmdutil.EnsureSuccessStatus(resp), "failed to store recovery key")
+}
+
+func init() {
+ BackupsCmd.AddCommand(listCmd)
+ BackupsCmd.AddCommand(createCmd)
+ BackupsCmd.AddCommand(deleteCmd)
+ BackupsCmd.AddCommand(restoreCmd)
+ BackupsCmd.AddCommand(uploadCmd)
+ BackupsCmd.AddCommand(discoverCmd)
+ BackupsCmd.AddCommand(policiesCmd)
+ BackupsCmd.AddCommand(recoveryKeyCmd)
+
+ policiesCmd.AddCommand(policiesUpdateCmd)
+ recoveryKeyCmd.AddCommand(recoveryKeyGenerateCmd)
+ recoveryKeyCmd.AddCommand(recoveryKeySetCmd)
+
+ listCmd.Flags().IntVarP(&limitFlag, "limit", "n", 20, "Number of backups to show")
+ listCmd.Flags().IntVar(&startFlag, "start", 0, cmdutil.StartFlagUsage)
+ listCmd.Flags().BoolVarP(&allFlag, "all", "a", false, cmdutil.AllFlagUsage)
+ listCmd.Flags().BoolVar(&jsonOutput, "json", false, "Output in JSON format")
+
+ createCmd.Flags().StringVar(&createDestination, "destination", "", "Backup destination: local, s3, or local_s3 (inferred from --local/--s3-destination when omitted)")
+ createCmd.Flags().StringVar(&createS3Destination, "s3-destination", "", "S3 destination name or ID")
+ createCmd.Flags().BoolVar(&createLocal, "local", false, "Also keep a local copy when backing up to S3")
+ createCmd.Flags().StringVar(&createRecoveryKey, "recovery-key", "", "Recovery key used to encrypt the backup")
+ createCmd.Flags().StringVar(&createPolicyID, "policy", "", "Backup policy ID to associate with the run")
+ createCmd.Flags().BoolVar(&jsonOutput, "json", false, "Output in JSON format")
+
+ deleteCmd.Flags().StringVar(&deleteRecoveryKey, "recovery-key", "", "Recovery key (required to delete remote snapshots)")
+ deleteCmd.Flags().BoolVarP(&forceFlag, "force", "f", false, "Delete without confirmation")
+ deleteCmd.Flags().BoolVar(&jsonOutput, "json", false, "Output in JSON format")
+
+ restoreCmd.Flags().StringVar(&restoreRecoveryKey, "recovery-key", "", "Recovery key the backup was encrypted with (prompted for when omitted)")
+ restoreCmd.Flags().BoolVarP(&forceFlag, "force", "f", false, "Restore without confirmation")
+ restoreCmd.Flags().BoolVar(&jsonOutput, "json", false, "Output in JSON format")
+
+ uploadCmd.Flags().StringVar(&uploadS3Destination, "s3-destination", "", "S3 destination name or ID to upload to")
+ uploadCmd.Flags().StringVar(&uploadRecoveryKey, "recovery-key", "", "Recovery key the backup was encrypted with")
+ uploadCmd.Flags().BoolVar(&jsonOutput, "json", false, "Output in JSON format")
+ _ = uploadCmd.MarkFlagRequired("s3-destination")
+
+ discoverCmd.Flags().StringVar(&discoverS3Destination, "s3-destination", "", "S3 destination name or ID to search")
+ discoverCmd.Flags().StringVar(&discoverRecoveryKey, "recovery-key", "", "Recovery key the backups were encrypted with")
+ discoverCmd.Flags().BoolVar(&jsonOutput, "json", false, "Output in JSON format")
+ _ = discoverCmd.MarkFlagRequired("s3-destination")
+
+ policiesCmd.Flags().BoolVar(&jsonOutput, "json", false, "Output in JSON format")
+
+ policiesUpdateCmd.Flags().StringVar(&policiesUpdateFile, "file", "", "JSON file with the full policies payload (use - for stdin); replaces all policies")
+ policiesUpdateCmd.Flags().StringVar(&policiesUpdateID, "policy-id", "", "Policy ID to update (defaults to the sole policy)")
+ policiesUpdateCmd.Flags().BoolVar(&policiesUpdateEnabled, "enabled", false, "Enable the policy")
+ policiesUpdateCmd.Flags().BoolVar(&policiesUpdateDisabled, "disabled", false, "Disable the policy")
+ policiesUpdateCmd.Flags().StringVar(&policiesUpdateSchedule, "schedule", "", "Cron schedule for automatic backups")
+ policiesUpdateCmd.Flags().IntVar(&policiesUpdateRetention, "retention", 0, "Number of backups to retain")
+ policiesUpdateCmd.Flags().BoolVar(&policiesUpdateLocal, "local", false, "Store backups in the local repository")
+ policiesUpdateCmd.Flags().BoolVar(&policiesUpdateS3, "s3", false, "Store backups in the S3 destination")
+ policiesUpdateCmd.Flags().StringVar(&policiesUpdateS3Destination, "s3-destination", "", "S3 destination name or ID (implies --s3)")
+ policiesUpdateCmd.Flags().BoolVar(&jsonOutput, "json", false, "Output in JSON format")
+ policiesUpdateCmd.MarkFlagsMutuallyExclusive("enabled", "disabled")
+
+ recoveryKeyGenerateCmd.Flags().BoolVar(&generateSave, "save", false, "Store the generated recovery key on the server")
+ recoveryKeyGenerateCmd.Flags().BoolVar(&jsonOutput, "json", false, "Output in JSON format")
+
+ recoveryKeySetCmd.Flags().StringVar(&setRecoveryKey, "recovery-key", "", "Recovery key to store (prompted for when omitted)")
+ recoveryKeySetCmd.Flags().BoolVar(&jsonOutput, "json", false, "Output in JSON format")
+}
diff --git a/cli/pkg/backups/resolve.go b/cli/pkg/backups/resolve.go
new file mode 100644
index 000000000..dbcdd9f8f
--- /dev/null
+++ b/cli/pkg/backups/resolve.go
@@ -0,0 +1,87 @@
+package backups
+
+import (
+ "context"
+ "fmt"
+ "strings"
+
+ "emperror.dev/errors"
+
+ "github.com/getarcaneapp/arcane/cli/v2/internal/client"
+ "github.com/getarcaneapp/arcane/cli/v2/internal/cmdutil"
+ "github.com/getarcaneapp/arcane/cli/v2/internal/prompt"
+ "github.com/getarcaneapp/arcane/cli/v2/internal/types"
+ "github.com/getarcaneapp/arcane/types/v2/backup"
+)
+
+const maxPromptOptions = 20
+
+// resolveS3Destination resolves an S3 destination identifier (ID or name) to
+// the saved destination: exact ID first, then exact name (case-insensitive),
+// then substring match. Multiple matches prompt interactively when allowed.
+func resolveS3Destination(ctx context.Context, c *client.Client, identifier string, allowPrompt bool) (*backup.S3Destination, error) {
+ trimmed := strings.TrimSpace(identifier)
+ if trimmed == "" {
+ return nil, errors.New("S3 destination name or ID is required")
+ }
+
+ resp, err := c.Get(ctx, types.BackupsS3Options())
+ if err != nil {
+ return nil, errors.WrapIf(err, "failed to list S3 destinations")
+ }
+ defer func() { _ = resp.Body.Close() }()
+ if err := cmdutil.EnsureSuccessStatus(resp); err != nil {
+ return nil, errors.WrapIf(err, "failed to list S3 destinations")
+ }
+
+ var destinations []backup.S3Destination
+ if err := cmdutil.DecodeJSON(resp, &destinations); err != nil {
+ return nil, err
+ }
+
+ for i := range destinations {
+ if destinations[i].ID == trimmed {
+ return &destinations[i], nil
+ }
+ }
+
+ matches := make([]backup.S3Destination, 0)
+ for _, dest := range destinations {
+ if strings.EqualFold(dest.Name, trimmed) {
+ matches = append(matches, dest)
+ }
+ }
+ if len(matches) == 0 {
+ identifierLower := strings.ToLower(trimmed)
+ for _, dest := range destinations {
+ if strings.Contains(strings.ToLower(dest.Name), identifierLower) {
+ matches = append(matches, dest)
+ }
+ }
+ }
+
+ if len(matches) == 1 {
+ return &matches[0], nil
+ }
+
+ if len(matches) > 1 {
+ if allowPrompt && prompt.IsInteractive() && len(matches) <= maxPromptOptions {
+ options := make([]string, 0, len(matches))
+ for _, match := range matches {
+ options = append(options, fmt.Sprintf("%s (%s, bucket %s)", match.Name, match.ID, match.Bucket))
+ }
+ choice, err := prompt.Select("S3 destination", options)
+ if err != nil {
+ return nil, err
+ }
+ return &matches[choice], nil
+ }
+ names := make([]string, 0, len(matches))
+ for _, match := range matches {
+ names = append(names, fmt.Sprintf("%s (%s)", match.Name, match.ID))
+ }
+ return nil, errors.Errorf("multiple S3 destinations match %q: %s; use the exact name or ID", trimmed, strings.Join(names, ", "))
+ }
+
+ return nil, errors.Errorf("S3 destination %q not found; run `arcane backups s3 list`", trimmed)
+}
diff --git a/cli/pkg/backups/s3.go b/cli/pkg/backups/s3.go
new file mode 100644
index 000000000..6adfe5195
--- /dev/null
+++ b/cli/pkg/backups/s3.go
@@ -0,0 +1,460 @@
+package backups
+
+import (
+ "encoding/json"
+ "fmt"
+ "net/http"
+ "strconv"
+
+ "emperror.dev/errors"
+
+ "github.com/getarcaneapp/arcane/cli/v2/internal/cmdutil"
+ "github.com/getarcaneapp/arcane/cli/v2/internal/output"
+ "github.com/getarcaneapp/arcane/cli/v2/internal/types"
+ "github.com/getarcaneapp/arcane/types/v2/backup"
+ "github.com/getarcaneapp/arcane/types/v2/base"
+ "github.com/spf13/cobra"
+)
+
+var (
+ s3Name string
+ s3Endpoint string
+ s3Bucket string
+ s3Region string
+ s3AccessKeyID string
+ s3SecretAccessKey string
+ s3Prefix string
+ s3UseSSL bool
+ s3ForcePathStyle bool
+
+ s3GetInUse bool
+)
+
+var s3Cmd = &cobra.Command{
+ Use: "s3",
+ Short: "Manage S3 backup destinations",
+}
+
+var s3ListCmd = &cobra.Command{
+ Use: "list",
+ Aliases: []string{"ls"},
+ Short: "List S3 backup destinations",
+ SilenceUsage: true,
+ RunE: func(cmd *cobra.Command, args []string) error {
+ c, err := cmdutil.ClientFromCommand(cmd)
+ if err != nil {
+ return err
+ }
+
+ path, err := cmdutil.ApplyPaginationParams(cmd, types.BackupsS3(), cmdutil.ListParams{
+ Resource: "s3 destinations",
+ Limit: limitFlag,
+ FallbackDefault: 20,
+ Start: startFlag,
+ All: allFlag,
+ })
+ if err != nil {
+ return errors.WrapIf(err, "failed to build pagination query")
+ }
+
+ resp, err := c.Get(cmd.Context(), path)
+ if err != nil {
+ return errors.WrapIf(err, "failed to list S3 destinations")
+ }
+ defer func() { _ = resp.Body.Close() }()
+
+ body, err := cmdutil.ReadJSONBody(resp)
+ if err != nil {
+ return errors.WrapIf(err, "failed to list S3 destinations")
+ }
+
+ if cmdutil.JSONOutputEnabled(cmd) {
+ return cmdutil.PrintRawJSON(body)
+ }
+
+ var result base.Paginated[backup.S3Destination]
+ if err := json.Unmarshal(body, &result); err != nil {
+ return errors.WrapIf(err, "failed to parse response")
+ }
+
+ output.Table(s3TableHeaders(), s3TableRows(result.Data))
+ output.Showing(len(result.Data), result.Pagination.TotalItems, "S3 destinations")
+ return nil
+ },
+}
+
+func s3TableHeaders() []string {
+ return []string{"ID", "NAME", "BUCKET", "REGION", "ENDPOINT", "SSL", "SECRET"}
+}
+
+func s3TableRows(destinations []backup.S3Destination) [][]string {
+ rows := make([][]string, len(destinations))
+ for i, dest := range destinations {
+ secret := "Not set"
+ if dest.SecretConfigured {
+ secret = "Set"
+ }
+ rows[i] = []string{
+ dest.ID,
+ dest.Name,
+ dest.Bucket,
+ dest.Region,
+ dest.Endpoint,
+ strconv.FormatBool(dest.UseSSL),
+ secret,
+ }
+ }
+ return rows
+}
+
+var s3GetCmd = &cobra.Command{
+ Use: "get <destination>",
+ Short: "Get S3 destination details by name or ID",
+ Args: cobra.ExactArgs(1),
+ SilenceUsage: true,
+ RunE: func(cmd *cobra.Command, args []string) error {
+ c, err := cmdutil.ClientFromCommand(cmd)
+ if err != nil {
+ return err
+ }
+
+ resolved, err := resolveS3Destination(cmd.Context(), c, args[0], !cmdutil.JSONOutputEnabled(cmd))
+ if err != nil {
+ return err
+ }
+
+ resp, err := c.Get(cmd.Context(), types.BackupsS3Destination(resolved.ID))
+ if err != nil {
+ return errors.WrapIf(err, "failed to get S3 destination")
+ }
+ defer func() { _ = resp.Body.Close() }()
+
+ body, err := cmdutil.ReadJSONBody(resp)
+ if err != nil {
+ return errors.WrapIf(err, "failed to get S3 destination")
+ }
+
+ if !s3GetInUse {
+ if cmdutil.JSONOutputEnabled(cmd) {
+ return cmdutil.PrintRawJSON(body)
+ }
+ var dest backup.S3Destination
+ if err := json.Unmarshal(body, &dest); err != nil {
+ return errors.WrapIf(err, "failed to parse response")
+ }
+ printS3Destination(dest)
+ return nil
+ }
+
+ var dest backup.S3Destination
+ if err := json.Unmarshal(body, &dest); err != nil {
+ return errors.WrapIf(err, "failed to parse response")
+ }
+
+ usageResp, err := c.Get(cmd.Context(), types.BackupsS3DestinationInUse(resolved.ID))
+ if err != nil {
+ return errors.WrapIf(err, "failed to check S3 destination usage")
+ }
+ defer func() { _ = usageResp.Body.Close() }()
+
+ var usage struct {
+ InUse bool `json:"inUse"`
+ }
+ if err := cmdutil.DecodeJSON(usageResp, &usage); err != nil {
+ return err
+ }
+
+ if cmdutil.JSONOutputEnabled(cmd) {
+ return cmdutil.PrintJSON(map[string]any{"destination": dest, "inUse": usage.InUse})
+ }
+
+ printS3Destination(dest)
+ if usage.InUse {
+ output.KeyValue("In Use", "Yes (referenced by backups, policies, or settings)")
+ } else {
+ output.KeyValue("In Use", "No")
+ }
+ return nil
+ },
+}
+
+func printS3Destination(dest backup.S3Destination) {
+ output.Header("S3 Destination Details")
+ output.KeyValue("ID", dest.ID)
+ output.KeyValue("Name", dest.Name)
+ output.KeyValue("Bucket", dest.Bucket)
+ output.KeyValue("Region", dest.Region)
+ if dest.Endpoint != "" {
+ output.KeyValue("Endpoint", dest.Endpoint)
+ }
+ if dest.Prefix != "" {
+ output.KeyValue("Prefix", dest.Prefix)
+ }
+ output.KeyValue("Access Key ID", dest.AccessKeyID)
+ output.KeyValue("Secret Configured", dest.SecretConfigured)
+ output.KeyValue("Use SSL", dest.UseSSL)
+ output.KeyValue("Force Path Style", dest.ForcePathStyle)
+ output.KeyValue("Created", dest.CreatedAt.Format("2006-01-02 15:04"))
+}
+
+func s3DestinationFromFlags() backup.CreateS3Destination {
+ return backup.CreateS3Destination{
+ Name: s3Name,
+ Endpoint: s3Endpoint,
+ Bucket: s3Bucket,
+ Region: s3Region,
+ AccessKeyID: s3AccessKeyID,
+ SecretAccessKey: s3SecretAccessKey,
+ Prefix: s3Prefix,
+ UseSSL: s3UseSSL,
+ ForcePathStyle: s3ForcePathStyle,
+ }
+}
+
+var s3CreateCmd = &cobra.Command{
+ Use: "create",
+ Short: "Create an S3 backup destination",
+ Args: cobra.NoArgs,
+ SilenceUsage: true,
+ RunE: func(cmd *cobra.Command, args []string) error {
+ c, err := cmdutil.ClientFromCommand(cmd)
+ if err != nil {
+ return err
+ }
+
+ resp, err := c.Post(cmd.Context(), types.BackupsS3(), s3DestinationFromFlags())
+ if err != nil {
+ return errors.WrapIf(err, "failed to create S3 destination")
+ }
+ defer func() { _ = resp.Body.Close() }()
+ if err := cmdutil.EnsureSuccessStatus(resp); err != nil {
+ return errors.WrapIf(err, "failed to create S3 destination")
+ }
+
+ body, err := cmdutil.ReadJSONBody(resp)
+ if err != nil {
+ return errors.WrapIf(err, "failed to create S3 destination")
+ }
+
+ if cmdutil.JSONOutputEnabled(cmd) {
+ return cmdutil.PrintRawJSON(body)
+ }
+
+ var dest backup.S3Destination
+ if err := json.Unmarshal(body, &dest); err != nil {
+ return errors.WrapIf(err, "failed to parse response")
+ }
+
+ output.Success("S3 destination %s created successfully", dest.Name)
+ printS3Destination(dest)
+ return nil
+ },
+}
+
+var s3UpdateCmd = &cobra.Command{
+ Use: "update <destination>",
+ Short: "Update an S3 backup destination by name or ID",
+ Args: cobra.ExactArgs(1),
+ SilenceUsage: true,
+ RunE: func(cmd *cobra.Command, args []string) error {
+ c, err := cmdutil.ClientFromCommand(cmd)
+ if err != nil {
+ return err
+ }
+
+ resolved, err := resolveS3Destination(cmd.Context(), c, args[0], !cmdutil.JSONOutputEnabled(cmd))
+ if err != nil {
+ return err
+ }
+
+ resp, err := c.Put(cmd.Context(), types.BackupsS3Destination(resolved.ID), s3DestinationFromFlags())
+ if err != nil {
+ return errors.WrapIf(err, "failed to update S3 destination")
+ }
+ defer func() { _ = resp.Body.Close() }()
+ if err := cmdutil.EnsureSuccessStatus(resp); err != nil {
+ return errors.WrapIf(err, "failed to update S3 destination")
+ }
+
+ body, err := cmdutil.ReadJSONBody(resp)
+ if err != nil {
+ return errors.WrapIf(err, "failed to update S3 destination")
+ }
+
+ if cmdutil.JSONOutputEnabled(cmd) {
+ return cmdutil.PrintRawJSON(body)
+ }
+
+ var dest backup.S3Destination
+ if err := json.Unmarshal(body, &dest); err != nil {
+ return errors.WrapIf(err, "failed to parse response")
+ }
+
+ output.Success("S3 destination %s updated successfully", dest.Name)
+ printS3Destination(dest)
+ return nil
+ },
+}
+
+var s3DeleteCmd = &cobra.Command{
+ Use: "delete <destination>",
+ Aliases: []string{"rm", "remove"},
+ Short: "Delete an S3 backup destination by name or ID",
+ Args: cobra.ExactArgs(1),
+ SilenceUsage: true,
+ RunE: func(cmd *cobra.Command, args []string) error {
+ c, err := cmdutil.ClientFromCommand(cmd)
+ if err != nil {
+ return err
+ }
+
+ resolved, err := resolveS3Destination(cmd.Context(), c, args[0], !forceFlag && !cmdutil.JSONOutputEnabled(cmd))
+ if err != nil {
+ return err
+ }
+
+ if !forceFlag {
+ confirmed, err := cmdutil.Confirm(cmd, fmt.Sprintf("Are you sure you want to delete S3 destination %s?", resolved.Name))
+ if err != nil {
+ return err
+ }
+ if !confirmed {
+ fmt.Println("Cancelled")
+ return nil
+ }
+ }
+
+ resp, err := c.Delete(cmd.Context(), types.BackupsS3Destination(resolved.ID))
+ if err != nil {
+ return errors.WrapIf(err, "failed to delete S3 destination")
+ }
+ defer func() { _ = resp.Body.Close() }()
+ if err := cmdutil.EnsureSuccessStatus(resp); err != nil {
+ return errors.WrapIf(err, "failed to delete S3 destination")
+ }
+
+ if cmdutil.JSONOutputEnabled(cmd) {
+ body, err := cmdutil.ReadJSONBody(resp)
+ if err != nil {
+ return errors.WrapIf(err, "failed to delete S3 destination")
+ }
+ return cmdutil.PrintRawJSON(body)
+ }
+
+ output.Success("S3 destination %s deleted successfully", resolved.Name)
+ return nil
+ },
+}
+
+var s3TestCmd = &cobra.Command{
+ Use: "test [destination]",
+ Short: "Test an S3 destination connection",
+ Long: `Test a saved S3 destination by name or ID, or an unsaved configuration by
+passing the connection flags (--name, --bucket, --region, ...) with no argument.`,
+ Args: cobra.MaximumNArgs(1),
+ SilenceUsage: true,
+ RunE: func(cmd *cobra.Command, args []string) error {
+ connectionFlagsSet := false
+ for _, name := range []string{"name", "endpoint", "bucket", "region", "access-key-id", "secret-access-key", "prefix", "use-ssl", "force-path-style"} {
+ if cmd.Flags().Changed(name) {
+ connectionFlagsSet = true
+ break
+ }
+ }
+
+ c, err := cmdutil.ClientFromCommand(cmd)
+ if err != nil {
+ return err
+ }
+
+ var resp *http.Response
+ if len(args) == 1 {
+ if connectionFlagsSet {
+ return errors.New("pass either a saved destination name or ID, or the connection flags, not both")
+ }
+ resolved, err := resolveS3Destination(cmd.Context(), c, args[0], !cmdutil.JSONOutputEnabled(cmd))
+ if err != nil {
+ return err
+ }
+ resp, err = c.Post(cmd.Context(), types.BackupsS3DestinationTest(resolved.ID), nil)
+ if err != nil {
+ return errors.WrapIf(err, "failed to test S3 destination")
+ }
+ } else {
+ if s3Bucket == "" {
+ return errors.New("either a destination name or ID, or connection flags (--name, --bucket, --region, ...) are required")
+ }
+ resp, err = c.Post(cmd.Context(), types.BackupsS3Test(), s3DestinationFromFlags())
+ if err != nil {
+ return errors.WrapIf(err, "failed to test S3 destination")
+ }
+ }
+ defer func() { _ = resp.Body.Close() }()
+ if err := cmdutil.EnsureSuccessStatus(resp); err != nil {
+ return errors.WrapIf(err, "failed to test S3 destination")
+ }
+
+ if cmdutil.JSONOutputEnabled(cmd) {
+ body, err := cmdutil.ReadJSONBody(resp)
+ if err != nil {
+ return errors.WrapIf(err, "failed to test S3 destination")
+ }
+ return cmdutil.PrintRawJSON(body)
+ }
+
+ output.Success("S3 connection test succeeded")
+ return nil
+ },
+}
+
+func addS3ConnectionFlags(cmd *cobra.Command) {
+ cmd.Flags().StringVar(&s3Name, "name", "", "Destination name")
+ cmd.Flags().StringVar(&s3Endpoint, "endpoint", "", "S3 endpoint (empty for AWS S3)")
+ cmd.Flags().StringVar(&s3Bucket, "bucket", "", "Bucket name")
+ cmd.Flags().StringVar(&s3Region, "region", "", "Region")
+ cmd.Flags().StringVar(&s3AccessKeyID, "access-key-id", "", "Access key ID")
+ cmd.Flags().StringVar(&s3SecretAccessKey, "secret-access-key", "", "Secret access key")
+ cmd.Flags().StringVar(&s3Prefix, "prefix", "", "Object key prefix")
+ cmd.Flags().BoolVar(&s3UseSSL, "use-ssl", true, "Use SSL for the connection")
+ cmd.Flags().BoolVar(&s3ForcePathStyle, "force-path-style", false, "Use path-style bucket addressing")
+}
+
+func init() {
+ BackupsCmd.AddCommand(s3Cmd)
+
+ s3Cmd.AddCommand(s3ListCmd)
+ s3Cmd.AddCommand(s3GetCmd)
+ s3Cmd.AddCommand(s3CreateCmd)
+ s3Cmd.AddCommand(s3UpdateCmd)
+ s3Cmd.AddCommand(s3DeleteCmd)
+ s3Cmd.AddCommand(s3TestCmd)
+
+ s3ListCmd.Flags().IntVarP(&limitFlag, "limit", "n", 20, "Number of destinations to show")
+ s3ListCmd.Flags().IntVar(&startFlag, "start", 0, cmdutil.StartFlagUsage)
+ s3ListCmd.Flags().BoolVarP(&allFlag, "all", "a", false, cmdutil.AllFlagUsage)
+ s3ListCmd.Flags().BoolVar(&jsonOutput, "json", false, "Output in JSON format")
+
+ s3GetCmd.Flags().BoolVar(&jsonOutput, "json", false, "Output in JSON format")
+ s3GetCmd.Flags().BoolVar(&s3GetInUse, "in-use", false, "Also report whether the destination is still referenced")
+
+ addS3ConnectionFlags(s3CreateCmd)
+ s3CreateCmd.Flags().BoolVar(&jsonOutput, "json", false, "Output in JSON format")
+ _ = s3CreateCmd.MarkFlagRequired("name")
+ _ = s3CreateCmd.MarkFlagRequired("bucket")
+ _ = s3CreateCmd.MarkFlagRequired("region")
+ _ = s3CreateCmd.MarkFlagRequired("access-key-id")
+ _ = s3CreateCmd.MarkFlagRequired("secret-access-key")
+
+ addS3ConnectionFlags(s3UpdateCmd)
+ s3UpdateCmd.Flags().BoolVar(&jsonOutput, "json", false, "Output in JSON format")
+ _ = s3UpdateCmd.MarkFlagRequired("name")
+ _ = s3UpdateCmd.MarkFlagRequired("bucket")
+ _ = s3UpdateCmd.MarkFlagRequired("region")
+ _ = s3UpdateCmd.MarkFlagRequired("access-key-id")
+
+ addS3ConnectionFlags(s3TestCmd)
+ s3TestCmd.Flags().BoolVar(&jsonOutput, "json", false, "Output in JSON format")
+
+ s3DeleteCmd.Flags().BoolVarP(&forceFlag, "force", "f", false, "Delete without confirmation")
+ s3DeleteCmd.Flags().BoolVar(&jsonOutput, "json", false, "Output in JSON format")
+}
diff --git a/cli/pkg/containers/actions.go b/cli/pkg/containers/actions.go
new file mode 100644
index 000000000..632e94361
--- /dev/null
+++ b/cli/pkg/containers/actions.go
@@ -0,0 +1,301 @@
+package containers
+
+import (
+ "encoding/json"
+ "fmt"
+ "net/url"
+ "os"
+ "strings"
+ "time"
+
+ "emperror.dev/errors"
+
+ "github.com/getarcaneapp/arcane/cli/v2/internal/client"
+ "github.com/getarcaneapp/arcane/cli/v2/internal/cmdutil"
+ "github.com/getarcaneapp/arcane/cli/v2/internal/output"
+ "github.com/getarcaneapp/arcane/cli/v2/internal/types"
+ "github.com/getarcaneapp/arcane/types/v2/base"
+ "github.com/getarcaneapp/arcane/types/v2/container"
+ "github.com/spf13/cobra"
+)
+
+var (
+ killSignal string
+
+ commitRepository string
+ commitTag string
+ commitComment string
+ commitAuthor string
+ commitChanges []string
+ commitNoPause bool
+
+ editFile string
+
+ autoUpdateEnabled bool
+)
+
+var containersKillCmd = &cobra.Command{
+ Use: "kill <container-id|name>",
+ Short: "Kill a container (send a signal to its main process)",
+ Args: cobra.ExactArgs(1),
+ SilenceUsage: true,
+ RunE: func(cmd *cobra.Command, args []string) error {
+ return runContainerPostAction[base.MessageResponse](cmd, args[0], containerPostActionConfig[base.MessageResponse]{
+ endpoint: func(envID, containerID string) string {
+ path := types.ContainerKill(envID, containerID)
+ if signal := strings.TrimSpace(killSignal); signal != "" {
+ path += "?signal=" + url.QueryEscape(signal)
+ }
+ return path
+ },
+ failureMessage: "failed to kill container",
+ successVerb: "killed",
+ })
+ },
+}
+
+var containersPauseCmd = &cobra.Command{
+ Use: "pause <container-id|name>",
+ Short: "Pause a container",
+ Args: cobra.ExactArgs(1),
+ SilenceUsage: true,
+ RunE: func(cmd *cobra.Command, args []string) error {
+ return runContainerPostAction[base.MessageResponse](cmd, args[0], containerPostActionConfig[base.MessageResponse]{
+ endpoint: types.ContainerPause,
+ failureMessage: "failed to pause container",
+ successVerb: "paused",
+ })
+ },
+}
+
+var containersUnpauseCmd = &cobra.Command{
+ Use: "unpause <container-id|name>",
+ Short: "Unpause a container",
+ Args: cobra.ExactArgs(1),
+ SilenceUsage: true,
+ RunE: func(cmd *cobra.Command, args []string) error {
+ return runContainerPostAction[base.MessageResponse](cmd, args[0], containerPostActionConfig[base.MessageResponse]{
+ endpoint: types.ContainerUnpause,
+ failureMessage: "failed to unpause container",
+ successVerb: "unpaused",
+ })
+ },
+}
+
+var containersCommitCmd = &cobra.Command{
+ Use: "commit <container-id|name>",
+ Short: "Create an image from a container",
+ Args: cobra.ExactArgs(1),
+ SilenceUsage: true,
+ RunE: func(cmd *cobra.Command, args []string) error {
+ c, err := client.NewFromConfig()
+ if err != nil {
+ return err
+ }
+
+ resolved, _, err := resolveContainer(cmd.Context(), c, args[0], false)
+ if err != nil {
+ return err
+ }
+
+ body := container.CommitRequest{
+ Repository: commitRepository,
+ Tag: commitTag,
+ Comment: commitComment,
+ Author: commitAuthor,
+ Changes: commitChanges,
+ NoPause: commitNoPause,
+ }
+
+ c.SetTimeout(30 * time.Minute)
+
+ resp, err := c.Post(cmd.Context(), types.ContainerCommit(c.EnvID(), resolved.ID), body)
+ if err != nil {
+ return errors.WrapIf(err, "failed to commit container")
+ }
+ defer func() { _ = resp.Body.Close() }()
+ if err := cmdutil.EnsureSuccessStatus(resp); err != nil {
+ return errors.WrapIf(err, "failed to commit container")
+ }
+
+ var result base.ApiResponse[container.CommitResult]
+ if err := cmdutil.DecodeJSON(resp, &result); err != nil {
+ return err
+ }
+
+ if jsonOutput {
+ resultBytes, err := json.MarshalIndent(result.Data, "", " ")
+ if err != nil {
+ return errors.WrapIf(err, "failed to marshal JSON")
+ }
+ fmt.Println(string(resultBytes))
+ return nil
+ }
+
+ output.Success("Container %s committed successfully", containerDisplayName(resolved))
+ output.KeyValue("Image ID", result.Data.ID)
+ return nil
+ },
+}
+
+var containersEditCmd = &cobra.Command{
+ Use: "edit <container-id|name>",
+ Short: "Edit a container's configuration",
+ Long: "Without --file, prints the container's editable configuration as JSON (pipe it to a file, edit it, then re-apply). With --file, applies the edit payload and recreates the container.",
+ Args: cobra.ExactArgs(1),
+ SilenceUsage: true,
+ RunE: func(cmd *cobra.Command, args []string) error {
+ c, err := client.NewFromConfig()
+ if err != nil {
+ return err
+ }
+
+ resolved, _, err := resolveContainer(cmd.Context(), c, args[0], false)
+ if err != nil {
+ return err
+ }
+
+ if editFile == "" {
+ resp, err := c.Get(cmd.Context(), types.ContainerEditConfig(c.EnvID(), resolved.ID))
+ if err != nil {
+ return errors.WrapIf(err, "failed to get container edit config")
+ }
+ defer func() { _ = resp.Body.Close() }()
+ if err := cmdutil.EnsureSuccessStatus(resp); err != nil {
+ return errors.WrapIf(err, "failed to get container edit config")
+ }
+
+ var result base.ApiResponse[container.EditConfig]
+ if err := cmdutil.DecodeJSON(resp, &result); err != nil {
+ return err
+ }
+
+ resultBytes, err := json.MarshalIndent(result.Data, "", " ")
+ if err != nil {
+ return errors.WrapIf(err, "failed to marshal JSON")
+ }
+ fmt.Println(string(resultBytes))
+ return nil
+ }
+
+ data, err := os.ReadFile(editFile)
+ if err != nil {
+ return errors.WrapIff(err, "failed to read file %s", editFile)
+ }
+ var body container.Edit
+ if err := json.Unmarshal(data, &body); err != nil {
+ return errors.WrapIf(err, "failed to parse edit payload")
+ }
+
+ c.SetTimeout(30 * time.Minute)
+
+ resp, err := c.Post(cmd.Context(), types.ContainerEdit(c.EnvID(), resolved.ID), body)
+ if err != nil {
+ return errors.WrapIf(err, "failed to edit container")
+ }
+ defer func() { _ = resp.Body.Close() }()
+ if err := cmdutil.EnsureSuccessStatus(resp); err != nil {
+ return errors.WrapIf(err, "failed to edit container")
+ }
+
+ var result base.ApiResponse[container.Details]
+ if err := cmdutil.DecodeJSON(resp, &result); err != nil {
+ return err
+ }
+
+ if jsonOutput {
+ resultBytes, err := json.MarshalIndent(result.Data, "", " ")
+ if err != nil {
+ return errors.WrapIf(err, "failed to marshal JSON")
+ }
+ fmt.Println(string(resultBytes))
+ return nil
+ }
+
+ output.Success("Container %s edited successfully", containerDisplayName(resolved))
+ output.KeyValue("New ID", result.Data.ID)
+ return nil
+ },
+}
+
+var containersAutoUpdateCmd = &cobra.Command{
+ Use: "autoupdate <container-id|name>",
+ Short: "Enable or disable auto-update for a container",
+ Args: cobra.ExactArgs(1),
+ SilenceUsage: true,
+ RunE: func(cmd *cobra.Command, args []string) error {
+ c, err := client.NewFromConfig()
+ if err != nil {
+ return err
+ }
+
+ resolved, _, err := resolveContainer(cmd.Context(), c, args[0], false)
+ if err != nil {
+ return err
+ }
+
+ body := struct {
+ Enabled bool `json:"enabled"`
+ }{Enabled: autoUpdateEnabled}
+
+ resp, err := c.Put(cmd.Context(), types.ContainerAutoUpdate(c.EnvID(), resolved.ID), body)
+ if err != nil {
+ return errors.WrapIf(err, "failed to set container auto-update")
+ }
+ defer func() { _ = resp.Body.Close() }()
+ if err := cmdutil.EnsureSuccessStatus(resp); err != nil {
+ return errors.WrapIf(err, "failed to set container auto-update")
+ }
+
+ var result base.ApiResponse[base.MessageResponse]
+ if err := cmdutil.DecodeJSON(resp, &result); err != nil {
+ return err
+ }
+
+ if jsonOutput {
+ resultBytes, err := json.MarshalIndent(result.Data, "", " ")
+ if err != nil {
+ return errors.WrapIf(err, "failed to marshal JSON")
+ }
+ fmt.Println(string(resultBytes))
+ return nil
+ }
+
+ state := "disabled"
+ if autoUpdateEnabled {
+ state = "enabled"
+ }
+ output.Success("Auto-update %s for container %s", state, containerDisplayName(resolved))
+ return nil
+ },
+}
+
+func init() {
+ ContainersCmd.AddCommand(containersKillCmd)
+ ContainersCmd.AddCommand(containersPauseCmd)
+ ContainersCmd.AddCommand(containersUnpauseCmd)
+ ContainersCmd.AddCommand(containersCommitCmd)
+ ContainersCmd.AddCommand(containersEditCmd)
+ ContainersCmd.AddCommand(containersAutoUpdateCmd)
+
+ containersKillCmd.Flags().StringVar(&killSignal, "signal", "", "Signal to send (for example SIGTERM, SIGKILL); defaults to SIGKILL")
+
+ containersCommitCmd.Flags().StringVar(&commitRepository, "repository", "", "Target image repository")
+ containersCommitCmd.Flags().StringVar(&commitTag, "tag", "", "Target image tag")
+ containersCommitCmd.Flags().StringVar(&commitComment, "comment", "", "Commit comment")
+ containersCommitCmd.Flags().StringVar(&commitAuthor, "author", "", "Commit author")
+ containersCommitCmd.Flags().StringArrayVar(&commitChanges, "change", nil, "Dockerfile instruction to apply during commit (repeatable)")
+ containersCommitCmd.Flags().BoolVar(&commitNoPause, "no-pause", false, "Do not pause the container during commit")
+
+ containersEditCmd.Flags().StringVarP(&editFile, "file", "f", "", "JSON edit payload to apply (omit to print the current editable configuration)")
+
+ containersAutoUpdateCmd.Flags().BoolVar(&autoUpdateEnabled, "enabled", false, "Whether auto-update is enabled for this container")
+ _ = containersAutoUpdateCmd.MarkFlagRequired("enabled")
+
+ containersKillCmd.Flags().BoolVar(&jsonOutput, "json", false, "Output in JSON format")
+ containersPauseCmd.Flags().BoolVar(&jsonOutput, "json", false, "Output in JSON format")
+ containersUnpauseCmd.Flags().BoolVar(&jsonOutput, "json", false, "Output in JSON format")
+ containersCommitCmd.Flags().BoolVar(&jsonOutput, "json", false, "Output in JSON format")
+ containersEditCmd.Flags().BoolVar(&jsonOutput, "json", false, "Output in JSON format")
+ containersAutoUpdateCmd.Flags().BoolVar(&jsonOutput, "json", false, "Output in JSON format")
+}
diff --git a/cli/pkg/containers/cmd.go b/cli/pkg/containers/cmd.go
index 3b20556a0..5ed04208b 100644
--- a/cli/pkg/containers/cmd.go
+++ b/cli/pkg/containers/cmd.go
@@ -154,7 +154,7 @@ func runContainersList(cmd *cobra.Command, forceHasUpdateFilter bool) error {
}
func buildContainersListPath(cmd *cobra.Command, c *client.Client, forceHasUpdateFilter bool) (string, error) {
- path, err := cmdutil.ApplyPaginationParams(cmd, types.Endpoints.Containers(c.EnvID()), cmdutil.ListParams{
+ path, err := cmdutil.ApplyPaginationParams(cmd, types.Containers(c.EnvID()), cmdutil.ListParams{
Resource: "containers",
Limit: containersLimit,
FallbackDefault: 20,
@@ -233,7 +233,7 @@ var containersGetCmd = &cobra.Command{
}
if !complete {
- path := types.Endpoints.Container(c.EnvID(), resolved.ID)
+ path := types.Container(c.EnvID(), resolved.ID)
resp, err := c.Get(cmd.Context(), path)
if err != nil {
return errors.WrapIf(err, "failed to get container")
@@ -273,7 +273,7 @@ var containersStartCmd = &cobra.Command{
SilenceUsage: true,
RunE: func(cmd *cobra.Command, args []string) error {
return runContainerPostAction[base.MessageResponse](cmd, args[0], containerPostActionConfig[base.MessageResponse]{
- endpoint: types.Endpoints.ContainerStart,
+ endpoint: types.ContainerStart,
failureMessage: "failed to start container",
successVerb: "started",
})
@@ -287,7 +287,7 @@ var containersStopCmd = &cobra.Command{
SilenceUsage: true,
RunE: func(cmd *cobra.Command, args []string) error {
return runContainerPostAction[base.MessageResponse](cmd, args[0], containerPostActionConfig[base.MessageResponse]{
- endpoint: types.Endpoints.ContainerStop,
+ endpoint: types.ContainerStop,
failureMessage: "failed to stop container",
successVerb: "stopped",
})
@@ -301,7 +301,7 @@ var containersRestartCmd = &cobra.Command{
SilenceUsage: true,
RunE: func(cmd *cobra.Command, args []string) error {
return runContainerPostAction[base.MessageResponse](cmd, args[0], containerPostActionConfig[base.MessageResponse]{
- endpoint: types.Endpoints.ContainerRestart,
+ endpoint: types.ContainerRestart,
failureMessage: "failed to restart container",
successVerb: "restarted",
})
@@ -317,7 +317,7 @@ var containersUpdateCmd = &cobra.Command{
// This route is served by the updater handler, so it answers with an
// updater.Result rather than a container.ActionResult.
return runContainerPostAction[updater.Result](cmd, args[0], containerPostActionConfig[updater.Result]{
- endpoint: types.Endpoints.ContainerUpdate,
+ endpoint: types.ContainerUpdate,
failureMessage: "failed to update container",
successVerb: "updated",
timeout: 30 * time.Minute,
@@ -332,7 +332,7 @@ var containersRedeployCmd = &cobra.Command{
SilenceUsage: true,
RunE: func(cmd *cobra.Command, args []string) error {
return runContainerPostAction[container.Details](cmd, args[0], containerPostActionConfig[container.Details]{
- endpoint: types.Endpoints.ContainerRedeploy,
+ endpoint: types.ContainerRedeploy,
failureMessage: "failed to redeploy container",
successVerb: "redeployed",
timeout: 30 * time.Minute,
@@ -424,7 +424,7 @@ var containersDeleteCmd = &cobra.Command{
query := url.Values{}
query.Set("force", strconv.FormatBool(forceFlag))
query.Set("volumes", strconv.FormatBool(containersDeleteVolumes))
- path := types.Endpoints.Container(c.EnvID(), resolved.ID) + "?" + query.Encode()
+ path := types.Container(c.EnvID(), resolved.ID) + "?" + query.Encode()
resp, err := c.Delete(cmd.Context(), path)
if err != nil {
return errors.WrapIf(err, "failed to delete container")
@@ -468,7 +468,7 @@ var containersCountsCmd = &cobra.Command{
return err
}
- path := types.Endpoints.ContainersCounts(c.EnvID())
+ path := types.ContainersCounts(c.EnvID())
resp, err := c.Get(cmd.Context(), path)
if err != nil {
return errors.WrapIf(err, "failed to get container counts")
@@ -593,7 +593,7 @@ var containersCreateCmd = &cobra.Command{
return errors.New("--image is required")
}
- path := types.Endpoints.Containers(c.EnvID())
+ path := types.Containers(c.EnvID())
resp, err := c.Post(cmd.Context(), path, req)
if err != nil {
return errors.WrapIf(err, "failed to create container")
@@ -749,7 +749,7 @@ func resolveContainer(ctx context.Context, c *client.Client, identifier string,
}
func fetchContainerByIdentifier(ctx context.Context, c *client.Client, identifier string) (*container.Details, bool, bool, error) {
- resp, err := c.Get(ctx, types.Endpoints.Container(c.EnvID(), identifier))
+ resp, err := c.Get(ctx, types.Container(c.EnvID(), identifier))
if err != nil {
return nil, false, false, errors.WrapIff(err, "failed to resolve container %q", identifier)
}
@@ -776,7 +776,7 @@ func fetchContainerByIdentifier(ctx context.Context, c *client.Client, identifie
}
func searchContainerMatches(ctx context.Context, c *client.Client, identifier string) ([]container.Summary, error) {
- searchPath := fmt.Sprintf("%s?search=%s&limit=%d", types.Endpoints.Containers(c.EnvID()), url.QueryEscape(identifier), cmdutil.ShowAllLimit)
+ searchPath := fmt.Sprintf("%s?search=%s&limit=%d", types.Containers(c.EnvID()), url.QueryEscape(identifier), cmdutil.ShowAllLimit)
searchResp, err := c.Get(ctx, searchPath)
if err != nil {
return nil, errors.WrapIf(err, "failed to search containers")
@@ -846,7 +846,7 @@ func containerDetailsFromSummary(summary container.Summary) *container.Details {
}
func fallbackContainerByIDPrefix(ctx context.Context, c *client.Client, identifierLower string) (*container.Details, bool, error) {
- fallbackPath := fmt.Sprintf("%s?limit=%d", types.Endpoints.Containers(c.EnvID()), cmdutil.ShowAllLimit)
+ fallbackPath := fmt.Sprintf("%s?limit=%d", types.Containers(c.EnvID()), cmdutil.ShowAllLimit)
fallbackResp, err := c.Get(ctx, fallbackPath)
if err != nil {
return nil, false, errors.WrapIf(err, "failed to search containers")
diff --git a/cli/pkg/environments/cmd.go b/cli/pkg/environments/cmd.go
index 2a11c2351..fff036427 100644
--- a/cli/pkg/environments/cmd.go
+++ b/cli/pkg/environments/cmd.go
@@ -37,6 +37,15 @@ var (
envUpdateDisabled bool
)
+var (
+ envCreateName string
+ envCreateApiUrl string
+ envCreateAccessToken string
+ envCreateUseApiKey bool
+ envCreateEdge bool
+ envCreateDisabled bool
+)
+
var (
statusOnlineStyle = lipgloss.NewStyle().Foreground(lipgloss.Color("#22c55e"))
statusOfflineStyle = lipgloss.NewStyle().Foreground(lipgloss.Color("#ef4444"))
@@ -62,7 +71,7 @@ var listCmd = &cobra.Command{
return err
}
- path := types.Endpoints.Environments()
+ path := types.Environments()
path, err = cmdutil.ApplyPaginationParams(cmd, path, cmdutil.ListParams{Resource: "environments", Limit: limitFlag, FallbackDefault: 20, Start: startFlag, All: allFlag})
if err != nil {
return errors.WrapIf(err, "failed to build pagination query")
@@ -133,7 +142,7 @@ var deleteCmd = &cobra.Command{
return err
}
- resp, err := c.Delete(cmd.Context(), types.Endpoints.Environment(args[0]))
+ resp, err := c.Delete(cmd.Context(), types.Environment(args[0]))
if err != nil {
return errors.WrapIf(err, "failed to delete environment")
}
@@ -158,7 +167,7 @@ var getCmd = &cobra.Command{
return err
}
- resp, err := c.Get(cmd.Context(), types.Endpoints.Environment(args[0]))
+ resp, err := c.Get(cmd.Context(), types.Environment(args[0]))
if err != nil {
return errors.WrapIf(err, "failed to get environment")
}
@@ -199,7 +208,7 @@ var testCmd = &cobra.Command{
return err
}
- resp, err := c.Post(cmd.Context(), types.Endpoints.EnvironmentTest(args[0]), nil)
+ resp, err := c.Post(cmd.Context(), types.EnvironmentTest(args[0]), nil)
if err != nil {
return errors.WrapIf(err, "failed to test environment")
}
@@ -243,7 +252,7 @@ var switchCmd = &cobra.Command{
return err
}
- path := fmt.Sprintf("%s?limit=%d", types.Endpoints.Environments(), cmdutil.ShowAllLimit)
+ path := fmt.Sprintf("%s?limit=%d", types.Environments(), cmdutil.ShowAllLimit)
resp, err := c.Get(cmd.Context(), path)
if err != nil {
return errors.WrapIf(err, "failed to list environments")
@@ -364,7 +373,7 @@ var updateCmd = &cobra.Command{
req.Enabled = new(false)
}
- resp, err := c.Put(cmd.Context(), types.Endpoints.Environment(args[0]), req)
+ resp, err := c.Put(cmd.Context(), types.Environment(args[0]), req)
if err != nil {
return errors.WrapIf(err, "failed to update environment")
}
@@ -396,6 +405,69 @@ var updateCmd = &cobra.Command{
},
}
+var createCmd = &cobra.Command{
+ Use: "create",
+ Short: "Create environment",
+ SilenceUsage: true,
+ RunE: func(cmd *cobra.Command, args []string) error {
+ c, err := client.NewFromConfig()
+ if err != nil {
+ return err
+ }
+
+ req := environment.Create{ApiUrl: envCreateApiUrl}
+ if cmd.Flags().Changed("name") {
+ req.Name = &envCreateName
+ }
+ if cmd.Flags().Changed("access-token") {
+ req.AccessToken = &envCreateAccessToken
+ }
+ if cmd.Flags().Changed("use-api-key") {
+ req.UseApiKey = &envCreateUseApiKey
+ }
+ if cmd.Flags().Changed("edge") {
+ req.IsEdge = &envCreateEdge
+ }
+ if cmd.Flags().Changed("disabled") {
+ req.Enabled = new(!envCreateDisabled)
+ }
+
+ resp, err := c.Post(cmd.Context(), types.Environments(), req)
+ if err != nil {
+ return errors.WrapIf(err, "failed to create environment")
+ }
+ defer func() { _ = resp.Body.Close() }()
+ if err := cmdutil.EnsureSuccessStatus(resp); err != nil {
+ return errors.WrapIf(err, "failed to create environment")
+ }
+
+ var result base.ApiResponse[environment.Environment]
+ if err := cmdutil.DecodeJSON(resp, &result); err != nil {
+ return err
+ }
+
+ if jsonOutput {
+ resultBytes, err := json.MarshalIndent(buildEnvironmentPayloadInternal(result.Data), "", " ")
+ if err != nil {
+ return errors.WrapIf(err, "failed to marshal JSON")
+ }
+ fmt.Println(string(resultBytes))
+ return nil
+ }
+
+ output.Success("Environment created successfully")
+ output.KeyValue("ID", result.Data.ID)
+ output.KeyValue("Name", result.Data.Name)
+ output.KeyValue("API URL", result.Data.ApiUrl)
+ output.KeyValue("Enabled", result.Data.Enabled)
+ if result.Data.ApiKey != nil && *result.Data.ApiKey != "" {
+ output.Warning("Pairing API key (shown only once) — store it now:")
+ output.KeyValue("API Key", *result.Data.ApiKey)
+ }
+ return nil
+ },
+}
+
var versionCmd = &cobra.Command{
Use: "version <id>",
Short: "Get environment version",
@@ -407,7 +479,7 @@ var versionCmd = &cobra.Command{
return err
}
- resp, err := c.Get(cmd.Context(), types.Endpoints.EnvironmentVersion(args[0]))
+ resp, err := c.Get(cmd.Context(), types.EnvironmentVersion(args[0]))
if err != nil {
return errors.WrapIf(err, "failed to get environment version")
}
@@ -478,6 +550,7 @@ func init() {
EnvironmentsCmd.AddCommand(switchCmd)
EnvironmentsCmd.AddCommand(updateCmd)
EnvironmentsCmd.AddCommand(versionCmd)
+ EnvironmentsCmd.AddCommand(createCmd)
// List command flags
listCmd.Flags().IntVarP(&limitFlag, "limit", "n", 20, "Number of environments to show")
@@ -504,4 +577,14 @@ func init() {
// Version command flags
versionCmd.Flags().BoolVar(&jsonOutput, "json", false, "Output in JSON format")
+
+ // Create command flags
+ createCmd.Flags().StringVar(&envCreateApiUrl, "api-url", "", "API URL of the environment (required)")
+ createCmd.Flags().StringVar(&envCreateName, "name", "", "Environment name")
+ createCmd.Flags().StringVar(&envCreateAccessToken, "access-token", "", "Access token for legacy pairing")
+ createCmd.Flags().BoolVar(&envCreateUseApiKey, "use-api-key", false, "Pair using a generated API key (shown once)")
+ createCmd.Flags().BoolVar(&envCreateEdge, "edge", false, "Create as an edge environment")
+ createCmd.Flags().BoolVar(&envCreateDisabled, "disabled", false, "Create environment in disabled state")
+ createCmd.Flags().BoolVar(&jsonOutput, "json", false, "Output in JSON format")
+ _ = createCmd.MarkFlagRequired("api-url")
}
diff --git a/cli/pkg/generate/api_key.go b/cli/pkg/generate/api_key.go
index 6ebc7802b..640a46c8c 100644
--- a/cli/pkg/generate/api_key.go
+++ b/cli/pkg/generate/api_key.go
@@ -15,9 +15,10 @@ const (
)
var apiKeyCmd = &cobra.Command{
- Use: "api-key",
- Short: "Generate a static admin API key",
- Long: `Generate a static Arcane API key suitable for ADMIN_STATIC_API_KEY. This is just a local generation, nothing is stored to the database with these commands.`,
+ Use: "apikey",
+ Aliases: []string{"api-key"},
+ Short: "Generate a static admin API key",
+ Long: `Generate a static Arcane API key suitable for ADMIN_STATIC_API_KEY. This is just a local generation, nothing is stored to the database with these commands.`,
RunE: func(cmd *cobra.Command, args []string) error {
return generateAPIKeyOutputInternal()
},
diff --git a/cli/pkg/gitops/cmd.go b/cli/pkg/gitops/cmd.go
index e86983756..c0008f03d 100644
--- a/cli/pkg/gitops/cmd.go
+++ b/cli/pkg/gitops/cmd.go
@@ -60,7 +60,7 @@ var listCmd = &cobra.Command{
return err
}
- path := types.Endpoints.GitOpsSyncs(c.EnvID())
+ path := types.GitOpsSyncs(c.EnvID())
path, err = cmdutil.ApplyPaginationParams(cmd, path, cmdutil.ListParams{Resource: "gitops-syncs", Limit: limitFlag, FallbackDefault: 20, Start: startFlag, All: allFlag})
if err != nil {
return errors.WrapIf(err, "failed to build pagination query")
@@ -147,7 +147,7 @@ var createCmd = &cobra.Command{
req.SyncInterval = &interval
}
- resp, err := c.Post(cmd.Context(), types.Endpoints.GitOpsSyncs(c.EnvID()), req)
+ resp, err := c.Post(cmd.Context(), types.GitOpsSyncs(c.EnvID()), req)
if err != nil {
return errors.WrapIf(err, "failed to create gitops sync")
}
@@ -194,7 +194,7 @@ var getCmd = &cobra.Command{
}
if !complete {
- resp, err := c.Get(cmd.Context(), types.Endpoints.GitOpsSync(c.EnvID(), resolved.ID))
+ resp, err := c.Get(cmd.Context(), types.GitOpsSync(c.EnvID(), resolved.ID))
if err != nil {
return errors.WrapIf(err, "failed to get gitops sync")
}
@@ -276,7 +276,7 @@ var updateCmd = &cobra.Command{
req.SyncInterval = &gitopsUpdateInterval
}
- resp, err := c.Put(cmd.Context(), types.Endpoints.GitOpsSync(c.EnvID(), resolved.ID), req)
+ resp, err := c.Put(cmd.Context(), types.GitOpsSync(c.EnvID(), resolved.ID), req)
if err != nil {
return errors.WrapIf(err, "failed to update gitops sync")
}
@@ -323,7 +323,7 @@ var deleteCmd = &cobra.Command{
}
}
- resp, err := c.Delete(cmd.Context(), types.Endpoints.GitOpsSync(c.EnvID(), resolved.ID))
+ resp, err := c.Delete(cmd.Context(), types.GitOpsSync(c.EnvID(), resolved.ID))
if err != nil {
return errors.WrapIf(err, "failed to delete gitops sync")
}
@@ -353,7 +353,7 @@ var statusCmd = &cobra.Command{
return err
}
- resp, err := c.Get(cmd.Context(), types.Endpoints.GitOpsSyncStatus(c.EnvID(), resolved.ID))
+ resp, err := c.Get(cmd.Context(), types.GitOpsSyncStatus(c.EnvID(), resolved.ID))
if err != nil {
return errors.WrapIf(err, "failed to get gitops sync status")
}
@@ -411,7 +411,7 @@ var syncCmd = &cobra.Command{
return err
}
- resp, err := c.Post(cmd.Context(), types.Endpoints.GitOpsSyncTrigger(c.EnvID(), resolved.ID), nil)
+ resp, err := c.Post(cmd.Context(), types.GitOpsSyncTrigger(c.EnvID(), resolved.ID), nil)
if err != nil {
return errors.WrapIf(err, "failed to trigger gitops sync")
}
@@ -460,7 +460,7 @@ var filesCmd = &cobra.Command{
return err
}
- filesPath := types.Endpoints.GitOpsSyncFiles(c.EnvID(), resolved.ID)
+ filesPath := types.GitOpsSyncFiles(c.EnvID(), resolved.ID)
if gitopsFilesPath != "" {
filesPath = cmdutil.AppendQuery(filesPath, url.Values{"path": []string{gitopsFilesPath}})
}
@@ -522,7 +522,7 @@ var importCmd = &cobra.Command{
// The endpoint accepts a batch, so a single sync still has to be wrapped
// in an array.
- resp, err := c.Post(cmd.Context(), types.Endpoints.GitOpsSyncsImport(c.EnvID()), []gitops.ImportGitOpsSyncRequest{req})
+ resp, err := c.Post(cmd.Context(), types.GitOpsSyncsImport(c.EnvID()), []gitops.ImportGitOpsSyncRequest{req})
if err != nil {
return errors.WrapIf(err, "failed to import gitops sync")
}
@@ -635,7 +635,7 @@ func resolveGitOpsSync(ctx context.Context, c *client.Client, identifier string,
return nil, false, errors.New("gitops sync identifier is required")
}
- resp, err := c.Get(ctx, types.Endpoints.GitOpsSync(c.EnvID(), trimmed))
+ resp, err := c.Get(ctx, types.GitOpsSync(c.EnvID(), trimmed))
if err != nil {
return nil, false, errors.WrapIff(err, "failed to resolve gitops sync %q", trimmed)
}
@@ -660,7 +660,7 @@ func resolveGitOpsSync(ctx context.Context, c *client.Client, identifier string,
identifierLower := strings.ToLower(trimmed)
- searchPath := fmt.Sprintf("%s?search=%s&limit=%d", types.Endpoints.GitOpsSyncs(c.EnvID()), url.QueryEscape(trimmed), cmdutil.ShowAllLimit)
+ searchPath := fmt.Sprintf("%s?search=%s&limit=%d", types.GitOpsSyncs(c.EnvID()), url.QueryEscape(trimmed), cmdutil.ShowAllLimit)
searchResp, err := c.Get(ctx, searchPath)
if err != nil {
return nil, false, errors.WrapIf(err, "failed to search gitops syncs")
diff --git a/cli/pkg/images/cmd.go b/cli/pkg/images/cmd.go
index 82db84157..5cc452381 100644
--- a/cli/pkg/images/cmd.go
+++ b/cli/pkg/images/cmd.go
@@ -31,15 +31,12 @@
package images
import (
- "bytes"
"context"
"encoding/json"
"fmt"
"io"
"net/http"
"net/url"
- "os"
- "path/filepath"
"sort"
"strings"
"time"
@@ -96,7 +93,7 @@ var imagesListCmd = &cobra.Command{
return errors.New("--inuse and --unused cannot be used together")
}
- path := types.Endpoints.Images(c.EnvID())
+ path := types.Images(c.EnvID())
// Parse the path to handle query params
u, err := url.Parse(path)
@@ -203,7 +200,7 @@ var imagesGetCmd = &cobra.Command{
if err != nil {
return err
}
- path := types.Endpoints.Image(c.EnvID(), imageID)
+ path := types.Image(c.EnvID(), imageID)
log.Debugf("Getting image details from: %s", path)
@@ -299,7 +296,7 @@ var imagesRemoveCmd = &cobra.Command{
if err != nil {
return err
}
- path := types.Endpoints.Image(c.EnvID(), imageID)
+ path := types.Image(c.EnvID(), imageID)
if removeForce {
u, err := url.Parse(path)
@@ -369,7 +366,7 @@ var imagesPullCmd = &cobra.Command{
c.SetTimeout(30 * time.Minute)
imageName := args[0]
- path := types.Endpoints.ImagesPull(c.EnvID())
+ path := types.ImagesPull(c.EnvID())
log.Debugf("Pulling image from: %s", path)
@@ -490,7 +487,7 @@ var imagesPruneCmd = &cobra.Command{
return err
}
- path := types.Endpoints.ImagesPrune(c.EnvID())
+ path := types.ImagesPrune(c.EnvID())
log.Debugf("Pruning images from: %s", path)
@@ -561,7 +558,7 @@ var imagesCountsCmd = &cobra.Command{
return err
}
- path := types.Endpoints.ImagesCounts(c.EnvID())
+ path := types.ImagesCounts(c.EnvID())
log.Debugf("Getting image counts from: %s", path)
@@ -619,87 +616,17 @@ var imagesUploadCmd = &cobra.Command{
filePath := args[0]
- // Open the file
- file, err := os.Open(filePath)
- if err != nil {
- return errors.WrapIf(err, "failed to open file")
- }
- defer func() { _ = file.Close() }()
- fileInfo, err := file.Stat()
- if err != nil {
- return errors.WrapIf(err, "failed to stat file")
- }
-
- // Create the chunked upload session; the file is sent as independently
- // retried chunks so reverse-proxy body limits never see the full size.
- var created struct {
- Success bool `json:"success"`
- Data uploadtypes.Session `json:"data"`
- }
- createPath := types.Endpoints.UploadSessions(c.EnvID(), uploadtypes.KindImage)
- if err := c.DoJSON(cmd.Context(), http.MethodPost, createPath, uploadtypes.CreateSessionRequest{
- Filename: filepath.Base(filePath),
- Size: fileInfo.Size(),
- }, &created); err != nil {
- return errors.WrapIf(err, "failed to create upload session")
- }
- session := created.Data
-
- log.Debugf("Uploading image %s as %d chunks of %d bytes (session %s)", filePath, session.TotalChunks, session.ChunkSize, session.ID)
output.Info("Uploading image: %s", filePath)
jsonOutput := cmdutil.JSONOutputEnabled(cmd)
- var progressUI *output.Progress
- if !jsonOutput {
- progressUI = output.StartProgress("Uploading", fileInfo.Size())
- defer progressUI.Stop()
- }
-
- deleteSession := func() {
- if resp, deleteErr := c.Delete(context.WithoutCancel(cmd.Context()), types.Endpoints.UploadSession(c.EnvID(), uploadtypes.KindImage, session.ID)); deleteErr == nil {
- _ = resp.Body.Close()
- }
- }
-
- buf := make([]byte, session.ChunkSize)
- for index := range session.TotalChunks {
- expected := session.ChunkSize
- if index == session.TotalChunks-1 {
- expected = session.Size - int64(index)*session.ChunkSize
- }
- if _, err := io.ReadFull(file, buf[:expected]); err != nil {
- deleteSession()
- return errors.WrapIf(err, "failed to read file")
- }
-
- chunkPath := types.Endpoints.UploadSessionChunk(c.EnvID(), uploadtypes.KindImage, session.ID, index)
- for attempt := 1; ; attempt++ {
- resp, chunkErr := c.RequestRaw(cmd.Context(), http.MethodPut, chunkPath, bytes.NewReader(buf[:expected]), map[string]string{"Content-Type": "application/octet-stream"})
- if chunkErr == nil {
- ok := resp.StatusCode >= 200 && resp.StatusCode < 300
- if !ok {
- errorBody, _ := io.ReadAll(io.LimitReader(resp.Body, 4096))
- chunkErr = errors.Errorf("chunk %d failed (status %d): %s", index, resp.StatusCode, strings.TrimSpace(string(errorBody)))
- }
- _ = resp.Body.Close()
- if ok {
- break
- }
- }
- if attempt >= 3 {
- deleteSession()
- return errors.WrapIf(chunkErr, "failed to upload image")
- }
- log.Debugf("Retrying chunk %d after error: %v", index, chunkErr)
- }
- if progressUI != nil {
- progressUI.Add(expected)
- }
+ sessionID, err := cmdutil.UploadFileInChunks(cmd.Context(), c, uploadtypes.KindImage, filePath, !jsonOutput)
+ if err != nil {
+ return err
}
- respBody, err := c.DoRaw(cmd.Context(), http.MethodPost, types.Endpoints.ImagesUpload(c.EnvID()), uploadtypes.ConsumeRequest{UploadID: session.ID})
+ respBody, err := c.DoRaw(cmd.Context(), http.MethodPost, types.ImagesUpload(c.EnvID()), uploadtypes.ConsumeRequest{UploadID: sessionID})
if err != nil {
- deleteSession()
+ cmdutil.AbortUploadSession(cmd.Context(), c, uploadtypes.KindImage, sessionID)
return errors.WrapIf(err, "failed to upload image")
}
@@ -801,7 +728,7 @@ func resolveImageID(ctx context.Context, c *client.Client, identifier string, al
}
func resolveImageByID(ctx context.Context, c *client.Client, identifier string) (string, bool, error) {
- resp, err := c.Get(ctx, types.Endpoints.Image(c.EnvID(), identifier))
+ resp, err := c.Get(ctx, types.Image(c.EnvID(), identifier))
if err != nil {
return "", false, errors.WrapIff(err, "failed to resolve image %q", identifier)
}
@@ -851,7 +778,7 @@ func buildImageSearchTerms(trimmed string) []string {
}
func searchImageMatches(ctx context.Context, c *client.Client, term, trimmed string) ([]image.Summary, error) {
- searchPath := fmt.Sprintf("%s?search=%s&limit=%d", types.Endpoints.Images(c.EnvID()), url.QueryEscape(term), cmdutil.ShowAllLimit)
+ searchPath := fmt.Sprintf("%s?search=%s&limit=%d", types.Images(c.EnvID()), url.QueryEscape(term), cmdutil.ShowAllLimit)
searchResp, err := c.Get(ctx, searchPath)
if err != nil {
return nil, errors.WrapIf(err, "failed to search images")
diff --git a/cli/pkg/images/extra.go b/cli/pkg/images/extra.go
new file mode 100644
index 000000000..fd9d44bc9
--- /dev/null
+++ b/cli/pkg/images/extra.go
@@ -0,0 +1,753 @@
+package images
+
+import (
+ "bufio"
+ "encoding/json"
+ "fmt"
+ "io"
+ "net/http"
+ "net/url"
+ "os"
+ "strconv"
+ "strings"
+ "time"
+
+ "emperror.dev/errors"
+
+ "github.com/getarcaneapp/arcane/cli/v2/internal/cmdutil"
+ "github.com/getarcaneapp/arcane/cli/v2/internal/logger"
+ "github.com/getarcaneapp/arcane/cli/v2/internal/output"
+ "github.com/getarcaneapp/arcane/cli/v2/internal/prompt"
+ "github.com/getarcaneapp/arcane/cli/v2/internal/types"
+ "github.com/getarcaneapp/arcane/types/v2/base"
+ "github.com/getarcaneapp/arcane/types/v2/image"
+ "github.com/spf13/cobra"
+)
+
+var imagesSearchCmd = &cobra.Command{
+ Use: "search <term>",
+ Short: "Search Docker Hub images",
+ Args: cobra.ExactArgs(1),
+ SilenceUsage: true,
+ RunE: func(cmd *cobra.Command, args []string) error {
+ log := logger.GetLogger()
+ c, err := cmdutil.ClientFromCommand(cmd)
+ if err != nil {
+ return err
+ }
+
+ path := types.ImagesSearch(c.EnvID()) + "?term=" + url.QueryEscape(args[0])
+
+ log.Debugf("Searching images from: %s", path)
+
+ resp, err := c.Get(cmd.Context(), path)
+ if err != nil {
+ return errors.WrapIf(err, "failed to search images")
+ }
+ defer func() { _ = resp.Body.Close() }()
+
+ body, err := cmdutil.ReadJSONBody(resp)
+ if err != nil {
+ return errors.WrapIf(err, "failed to search images")
+ }
+
+ if cmdutil.JSONOutputEnabled(cmd) {
+ return cmdutil.PrintRawJSON(body)
+ }
+
+ var result struct {
+ Success bool `json:"success"`
+ Data []image.SearchResult `json:"data"`
+ }
+ if err := json.Unmarshal(body, &result); err != nil {
+ return errors.WrapIf(err, "failed to parse response")
+ }
+
+ headers := []string{"NAME", "DESCRIPTION", "STARS", "OFFICIAL"}
+ var rows [][]string
+ for _, item := range result.Data {
+ official := ""
+ if item.Official {
+ official = "Yes"
+ }
+ rows = append(rows, []string{item.Name, truncateCell(item.Description, 60), strconv.Itoa(item.StarCount), official})
+ }
+
+ output.Table(headers, rows)
+ output.Showing(len(result.Data), int64(len(result.Data)), "results")
+
+ return nil
+ },
+}
+
+var imagesHistoryCmd = &cobra.Command{
+ Use: "history <image-id|name>",
+ Short: "Show image layer history",
+ Args: cobra.ExactArgs(1),
+ SilenceUsage: true,
+ RunE: func(cmd *cobra.Command, args []string) error {
+ log := logger.GetLogger()
+ c, err := cmdutil.ClientFromCommand(cmd)
+ if err != nil {
+ return err
+ }
+
+ jsonOutput := cmdutil.JSONOutputEnabled(cmd)
+ allowPrompt := !jsonOutput && prompt.IsInteractive()
+
+ imageID, err := resolveImageID(cmd.Context(), c, args[0], allowPrompt)
+ if err != nil {
+ return err
+ }
+ path := types.ImageHistory(c.EnvID(), imageID)
+
+ log.Debugf("Getting image history from: %s", path)
+
+ resp, err := c.Get(cmd.Context(), path)
+ if err != nil {
+ return errors.WrapIf(err, "failed to get image history")
+ }
+ defer func() { _ = resp.Body.Close() }()
+
+ body, err := cmdutil.ReadJSONBody(resp)
+ if err != nil {
+ return errors.WrapIf(err, "failed to get image history")
+ }
+
+ if jsonOutput {
+ return cmdutil.PrintRawJSON(body)
+ }
+
+ var result struct {
+ Success bool `json:"success"`
+ Data []image.HistoryItem `json:"data"`
+ }
+ if err := json.Unmarshal(body, &result); err != nil {
+ return errors.WrapIf(err, "failed to parse response")
+ }
+
+ headers := []string{"CREATED", "CREATED BY", "SIZE", "COMMENT"}
+ var rows [][]string
+ for _, item := range result.Data {
+ created := ""
+ if item.Created > 0 {
+ created = time.Unix(item.Created, 0).Format(time.RFC3339)
+ }
+ rows = append(rows, []string{created, truncateCell(item.CreatedBy, 60), output.Bytes(item.Size), truncateCell(item.Comment, 30)})
+ }
+
+ output.Table(headers, rows)
+
+ return nil
+ },
+}
+
+var imagesTagCmd = &cobra.Command{
+ Use: "tag <image-id|name> <new-ref>",
+ Short: "Add a repository tag to an image",
+ Args: cobra.ExactArgs(2),
+ SilenceUsage: true,
+ RunE: func(cmd *cobra.Command, args []string) error {
+ log := logger.GetLogger()
+ c, err := cmdutil.ClientFromCommand(cmd)
+ if err != nil {
+ return err
+ }
+
+ jsonOutput := cmdutil.JSONOutputEnabled(cmd)
+ allowPrompt := !jsonOutput && prompt.IsInteractive()
+
+ imageID, err := resolveImageID(cmd.Context(), c, args[0], allowPrompt)
+ if err != nil {
+ return err
+ }
+
+ repository, tag := splitImageRef(args[1])
+ if repository == "" {
+ return errors.New("target repository is required")
+ }
+
+ path := types.ImageTag(c.EnvID(), imageID)
+
+ log.Debugf("Tagging image via: %s", path)
+
+ resp, err := c.Post(cmd.Context(), path, image.TagRequest{Repository: repository, Tag: tag})
+ if err != nil {
+ return errors.WrapIf(err, "failed to tag image")
+ }
+ defer func() { _ = resp.Body.Close() }()
+
+ body, err := cmdutil.ReadJSONBody(resp)
+ if err != nil {
+ return errors.WrapIf(err, "failed to tag image")
+ }
+
+ if jsonOutput {
+ return cmdutil.PrintRawJSON(body)
+ }
+
+ var result struct {
+ Success bool `json:"success"`
+ Data base.MessageResponse `json:"data"`
+ }
+ if err := json.Unmarshal(body, &result); err != nil {
+ return errors.WrapIf(err, "failed to parse response")
+ }
+
+ output.Success("%s", result.Data.Message)
+
+ return nil
+ },
+}
+
+var imagesExportCmd = &cobra.Command{
+ Use: "export <image-id|name> [output-file]",
+ Short: "Download an image as a tar archive",
+ Args: cobra.RangeArgs(1, 2),
+ SilenceUsage: true,
+ RunE: func(cmd *cobra.Command, args []string) error {
+ log := logger.GetLogger()
+ c, err := cmdutil.ClientFromCommand(cmd)
+ if err != nil {
+ return err
+ }
+
+ // Exporting large images can take a long time
+ c.SetTimeout(30 * time.Minute)
+
+ allowPrompt := prompt.IsInteractive()
+
+ imageID, err := resolveImageID(cmd.Context(), c, args[0], allowPrompt)
+ if err != nil {
+ return err
+ }
+
+ outputFile := exportFileName(args[0])
+ if len(args) == 2 {
+ outputFile = args[1]
+ }
+
+ path := types.ImageExport(c.EnvID(), imageID)
+
+ log.Debugf("Exporting image from: %s", path)
+
+ resp, err := c.RequestRaw(cmd.Context(), http.MethodGet, path, nil, nil)
+ if err != nil {
+ return errors.WrapIf(err, "failed to export image")
+ }
+ defer func() { _ = resp.Body.Close() }()
+ if err := cmdutil.EnsureSuccessStatus(resp); err != nil {
+ return errors.WrapIf(err, "failed to export image")
+ }
+
+ file, err := os.Create(outputFile)
+ if err != nil {
+ return errors.WrapIf(err, "failed to create output file")
+ }
+
+ written, err := io.Copy(file, resp.Body)
+ if closeErr := file.Close(); closeErr != nil && err == nil {
+ err = closeErr
+ }
+ if err != nil {
+ _ = os.Remove(outputFile)
+ return errors.WrapIf(err, "failed to write image archive")
+ }
+
+ output.Success("Saved %s (%s)", outputFile, output.Bytes(written))
+
+ return nil
+ },
+}
+
+var (
+ attestationsPlatform string
+ attestationsPredicateType string
+ attestationsStatement bool
+)
+
+var imagesAttestationsCmd = &cobra.Command{
+ Use: "attestations <image>",
+ Short: "Show in-toto attestations attached to an image",
+ Args: cobra.ExactArgs(1),
+ SilenceUsage: true,
+ RunE: func(cmd *cobra.Command, args []string) error {
+ log := logger.GetLogger()
+ c, err := cmdutil.ClientFromCommand(cmd)
+ if err != nil {
+ return err
+ }
+
+ imageName := strings.TrimSpace(args[0])
+ if imageName == "" {
+ return errors.New("image identifier is required")
+ }
+
+ u, err := url.Parse(types.ImageAttestations(c.EnvID(), imageName))
+ if err != nil {
+ return errors.WrapIf(err, "failed to parse endpoint path")
+ }
+ q := u.Query()
+ if attestationsPlatform != "" {
+ q.Set("platform", attestationsPlatform)
+ }
+ if attestationsPredicateType != "" {
+ q.Set("predicateType", attestationsPredicateType)
+ }
+ if attestationsStatement {
+ q.Set("statement", "true")
+ }
+ u.RawQuery = q.Encode()
+ path := u.String()
+
+ log.Debugf("Getting image attestations from: %s", path)
+
+ resp, err := c.Get(cmd.Context(), path)
+ if err != nil {
+ return errors.WrapIf(err, "failed to get image attestations")
+ }
+ defer func() { _ = resp.Body.Close() }()
+
+ body, err := cmdutil.ReadJSONBody(resp)
+ if err != nil {
+ return errors.WrapIf(err, "failed to get image attestations")
+ }
+
+ if cmdutil.JSONOutputEnabled(cmd) || attestationsStatement {
+ return cmdutil.PrintRawJSON(body)
+ }
+
+ var result struct {
+ Success bool `json:"success"`
+ Data image.AttestationList `json:"data"`
+ }
+ if err := json.Unmarshal(body, &result); err != nil {
+ return errors.WrapIf(err, "failed to parse response")
+ }
+
+ output.Header("Image Attestations")
+ output.KeyValue("Image", result.Data.ImageRef)
+ output.KeyValue("Subject Digest", result.Data.SubjectDigest)
+ if result.Data.Platform != "" {
+ output.KeyValue("Platform", result.Data.Platform)
+ }
+
+ if len(result.Data.Attestations) == 0 {
+ output.Info("No attestations found")
+ return nil
+ }
+
+ headers := []string{"PREDICATE TYPE", "PLATFORM", "DIGEST", "SIZE"}
+ var rows [][]string
+ for _, att := range result.Data.Attestations {
+ rows = append(rows, []string{att.PredicateType, att.Platform, truncateCell(att.Digest, 19), output.Bytes(att.Size)})
+ }
+ fmt.Println()
+ output.Table(headers, rows)
+
+ return nil
+ },
+}
+
+var (
+ buildTags []string
+ buildDockerfile string
+ buildInlineFile string
+ buildArgs []string
+ buildTarget string
+ buildPlatforms []string
+ buildNetwork string
+ buildProvider string
+ buildNoCache bool
+ buildPull bool
+ buildPush bool
+ buildLoad bool
+)
+
+var imagesBuildCmd = &cobra.Command{
+ Use: "build <context-dir|git-url>",
+ Short: "Build an image with BuildKit on the server",
+ Long: "Build a Docker image using BuildKit with streaming progress output.\n\nThe context argument is a build context directory on the Arcane server or a Git URL.",
+ Args: cobra.ExactArgs(1),
+ SilenceUsage: true,
+ RunE: func(cmd *cobra.Command, args []string) error {
+ log := logger.GetLogger()
+ c, err := cmdutil.ClientFromCommand(cmd)
+ if err != nil {
+ return err
+ }
+
+ // Builds can take a long time
+ c.SetTimeout(30 * time.Minute)
+
+ requestBody := map[string]any{
+ "contextDir": args[0],
+ }
+ if buildDockerfile != "" {
+ requestBody["dockerfile"] = buildDockerfile
+ }
+ if buildInlineFile != "" {
+ content, err := os.ReadFile(buildInlineFile)
+ if err != nil {
+ return errors.WrapIf(err, "failed to read Dockerfile")
+ }
+ requestBody["dockerfileInline"] = string(content)
+ }
+ if len(buildTags) > 0 {
+ requestBody["tags"] = buildTags
+ }
+ if buildTarget != "" {
+ requestBody["target"] = buildTarget
+ }
+ if len(buildArgs) > 0 {
+ parsed := make(map[string]string, len(buildArgs))
+ for _, arg := range buildArgs {
+ key, value, ok := strings.Cut(arg, "=")
+ if !ok || key == "" {
+ return errors.Errorf("invalid build arg %q; expected KEY=VALUE", arg)
+ }
+ parsed[key] = value
+ }
+ requestBody["buildArgs"] = parsed
+ }
+ if len(buildPlatforms) > 0 {
+ requestBody["platforms"] = buildPlatforms
+ }
+ if buildNetwork != "" {
+ requestBody["network"] = buildNetwork
+ }
+ if buildProvider != "" {
+ requestBody["provider"] = buildProvider
+ }
+ if buildNoCache {
+ requestBody["noCache"] = true
+ }
+ if buildPull {
+ requestBody["pull"] = true
+ }
+ if buildPush {
+ requestBody["push"] = true
+ }
+ if buildLoad {
+ requestBody["load"] = true
+ }
+
+ path := types.ImagesBuild(c.EnvID())
+
+ log.Debugf("Building image via: %s", path)
+
+ resp, err := c.Post(cmd.Context(), path, requestBody)
+ if err != nil {
+ return errors.WrapIf(err, "failed to build image")
+ }
+ defer func() { _ = resp.Body.Close() }()
+ if err := cmdutil.EnsureSuccessStatus(resp); err != nil {
+ return errors.WrapIf(err, "failed to build image")
+ }
+
+ if cmdutil.JSONOutputEnabled(cmd) {
+ _, err = io.Copy(cmd.OutOrStdout(), resp.Body)
+ if err != nil {
+ return errors.WrapIf(err, "failed to read build stream")
+ }
+ return nil
+ }
+
+ if err := streamBuildOutput(resp.Body); err != nil {
+ return err
+ }
+
+ output.Success("Image built successfully")
+
+ return nil
+ },
+}
+
+// streamBuildOutput prints the build NDJSON stream: control frames (activity,
+// done, error) are interpreted, everything else is raw build output.
+func streamBuildOutput(body io.Reader) error {
+ scanner := bufio.NewScanner(body)
+ scanner.Buffer(make([]byte, 0, 64*1024), 1024*1024)
+ done := false
+ for scanner.Scan() {
+ line := scanner.Text()
+ trimmed := strings.TrimSpace(line)
+ if strings.HasPrefix(trimmed, "{") {
+ var frame struct {
+ Type string `json:"type"`
+ Done bool `json:"done"`
+ Error string `json:"error"`
+ }
+ if json.Unmarshal([]byte(trimmed), &frame) == nil {
+ if frame.Error != "" {
+ return errors.Errorf("build error: %s", frame.Error)
+ }
+ if frame.Done {
+ done = true
+ continue
+ }
+ if frame.Type != "" {
+ continue
+ }
+ }
+ }
+ fmt.Println(line)
+ }
+ if err := scanner.Err(); err != nil {
+ return errors.WrapIf(err, "failed to read build stream")
+ }
+ if !done {
+ return errors.New("build stream ended without completion frame")
+ }
+ return nil
+}
+
+var (
+ buildsLimit int
+ buildsStart int
+ buildsAll bool
+ buildsStatus string
+ buildsProvider string
+)
+
+var imagesBuildsCmd = &cobra.Command{
+ Use: "builds",
+ Short: "List image build history",
+ SilenceUsage: true,
+ RunE: func(cmd *cobra.Command, args []string) error {
+ log := logger.GetLogger()
+ c, err := cmdutil.ClientFromCommand(cmd)
+ if err != nil {
+ return err
+ }
+
+ u, err := url.Parse(types.ImageBuilds(c.EnvID()))
+ if err != nil {
+ return errors.WrapIf(err, "failed to parse endpoint path")
+ }
+ q := u.Query()
+ if buildsStatus != "" {
+ q.Set("status", buildsStatus)
+ }
+ if buildsProvider != "" {
+ q.Set("provider", buildsProvider)
+ }
+ u.RawQuery = q.Encode()
+
+ path, err := cmdutil.ApplyPaginationParams(cmd, u.String(), cmdutil.ListParams{
+ Resource: "builds",
+ Limit: buildsLimit,
+ FallbackDefault: 0,
+ Start: buildsStart,
+ All: buildsAll,
+ })
+ if err != nil {
+ return errors.WrapIf(err, "failed to build pagination query")
+ }
+
+ log.Debugf("Listing image builds from: %s", path)
+
+ resp, err := c.Get(cmd.Context(), path)
+ if err != nil {
+ return errors.WrapIf(err, "failed to list image builds")
+ }
+ defer func() { _ = resp.Body.Close() }()
+
+ body, err := cmdutil.ReadJSONBody(resp)
+ if err != nil {
+ return errors.WrapIf(err, "failed to list image builds")
+ }
+
+ if cmdutil.JSONOutputEnabled(cmd) {
+ return cmdutil.PrintRawJSON(body)
+ }
+
+ var result base.Paginated[image.BuildRecord]
+ if err := json.Unmarshal(body, &result); err != nil {
+ return errors.WrapIf(err, "failed to parse response")
+ }
+
+ headers := []string{"ID", "IMAGE", "STATUS", "STARTED", "DURATION"}
+ var rows [][]string
+ for _, record := range result.Data {
+ rows = append(rows, []string{
+ record.ID,
+ buildImageLabel(record),
+ output.TintStatus(record.Status),
+ record.CreatedAt.Format(time.RFC3339),
+ buildDurationLabel(record.DurationMs),
+ })
+ }
+
+ output.Table(headers, rows)
+ output.Showing(len(result.Data), result.Pagination.TotalItems, "builds")
+
+ return nil
+ },
+}
+
+var imagesBuildsGetCmd = &cobra.Command{
+ Use: "get <build-id>",
+ Short: "Get an image build history entry",
+ Args: cobra.ExactArgs(1),
+ SilenceUsage: true,
+ RunE: func(cmd *cobra.Command, args []string) error {
+ log := logger.GetLogger()
+ c, err := cmdutil.ClientFromCommand(cmd)
+ if err != nil {
+ return err
+ }
+
+ path := types.ImageBuild(c.EnvID(), args[0])
+
+ log.Debugf("Getting image build from: %s", path)
+
+ resp, err := c.Get(cmd.Context(), path)
+ if err != nil {
+ return errors.WrapIf(err, "failed to get image build")
+ }
+ defer func() { _ = resp.Body.Close() }()
+
+ body, err := cmdutil.ReadJSONBody(resp)
+ if err != nil {
+ return errors.WrapIf(err, "failed to get image build")
+ }
+
+ if cmdutil.JSONOutputEnabled(cmd) {
+ return cmdutil.PrintRawJSON(body)
+ }
+
+ var result struct {
+ Success bool `json:"success"`
+ Data image.BuildRecord `json:"data"`
+ }
+ if err := json.Unmarshal(body, &result); err != nil {
+ return errors.WrapIf(err, "failed to parse response")
+ }
+
+ record := result.Data
+
+ output.Header("Build Details")
+ output.KeyValue("ID", record.ID)
+ output.KeyValue("Status", output.TintStatus(record.Status))
+ if record.Provider != "" {
+ output.KeyValue("Provider", record.Provider)
+ }
+ output.KeyValue("Context", record.ContextDir)
+ if record.Dockerfile != "" {
+ output.KeyValue("Dockerfile", record.Dockerfile)
+ }
+ if len(record.Tags) > 0 {
+ output.KeyValue("Tags", strings.Join(record.Tags, ", "))
+ }
+ if len(record.Platforms) > 0 {
+ output.KeyValue("Platforms", strings.Join(record.Platforms, ", "))
+ }
+ if record.Username != nil && *record.Username != "" {
+ output.KeyValue("User", *record.Username)
+ }
+ output.KeyValue("Started", record.CreatedAt.Format(time.RFC3339))
+ if record.CompletedAt != nil {
+ output.KeyValue("Completed", record.CompletedAt.Format(time.RFC3339))
+ }
+ output.KeyValue("Duration", buildDurationLabel(record.DurationMs))
+ if record.Digest != nil && *record.Digest != "" {
+ output.KeyValue("Digest", *record.Digest)
+ }
+ if record.ErrorMessage != nil && *record.ErrorMessage != "" {
+ output.KeyValue("Error", *record.ErrorMessage)
+ }
+
+ if record.Output != nil && *record.Output != "" {
+ output.Header("Output")
+ fmt.Println(*record.Output)
+ if record.OutputTruncated {
+ output.Warning("Output was truncated")
+ }
+ }
+
+ return nil
+ },
+}
+
+func buildImageLabel(record image.BuildRecord) string {
+ if len(record.Tags) > 0 {
+ return record.Tags[0]
+ }
+ return truncateCell(record.ContextDir, 40)
+}
+
+func buildDurationLabel(durationMs *int64) string {
+ if durationMs == nil {
+ return ""
+ }
+ return (time.Duration(*durationMs) * time.Millisecond).Round(time.Second).String()
+}
+
+// splitImageRef splits an image reference into repository and tag. The tag is
+// only split off when the text after the final colon contains no slash, so
+// registry ports (registry:5000/repo) stay part of the repository.
+func splitImageRef(ref string) (string, string) {
+ ref = strings.TrimSpace(ref)
+ if idx := strings.LastIndex(ref, ":"); idx > 0 && !strings.Contains(ref[idx+1:], "/") {
+ return ref[:idx], ref[idx+1:]
+ }
+ return ref, ""
+}
+
+// exportFileName mirrors the server's default export filename for an image
+// reference, replacing separators with underscores.
+func exportFileName(imageName string) string {
+ name := strings.NewReplacer("/", "_", ":", "_", "@", "_").Replace(strings.TrimSpace(imageName))
+ name = strings.Trim(name, "._-")
+ if name == "" {
+ name = "image"
+ }
+ return name + ".tar"
+}
+
+func truncateCell(value string, limit int) string {
+ value = strings.ReplaceAll(value, "\n", " ")
+ if limit > 3 && len(value) > limit {
+ return value[:limit-3] + "..."
+ }
+ return value
+}
+
+func init() {
+ ImagesCmd.AddCommand(imagesSearchCmd)
+
+ ImagesCmd.AddCommand(imagesHistoryCmd)
+
+ ImagesCmd.AddCommand(imagesTagCmd)
+
+ ImagesCmd.AddCommand(imagesExportCmd)
+
+ ImagesCmd.AddCommand(imagesAttestationsCmd)
+ imagesAttestationsCmd.Flags().StringVar(&attestationsPlatform, "platform", "", "OCI platform selector (e.g. linux/amd64)")
+ imagesAttestationsCmd.Flags().StringVar(&attestationsPredicateType, "predicate-type", "", "Exact in-toto predicate type URI to include")
+ imagesAttestationsCmd.Flags().BoolVar(&attestationsStatement, "statement", false, "Include verbatim statement JSON bodies (implies JSON output)")
+
+ ImagesCmd.AddCommand(imagesBuildCmd)
+ imagesBuildCmd.Flags().StringArrayVarP(&buildTags, "tag", "t", nil, "Image tag (repeatable)")
+ imagesBuildCmd.Flags().StringVarP(&buildDockerfile, "file", "f", "", "Dockerfile path within the build context")
+ imagesBuildCmd.Flags().StringVar(&buildInlineFile, "dockerfile-inline", "", "Local Dockerfile whose content is sent as the inline Dockerfile")
+ imagesBuildCmd.Flags().StringArrayVar(&buildArgs, "build-arg", nil, "Build argument KEY=VALUE (repeatable)")
+ imagesBuildCmd.Flags().StringVar(&buildTarget, "target", "", "Target build stage")
+ imagesBuildCmd.Flags().StringArrayVar(&buildPlatforms, "platform", nil, "Target platform (repeatable)")
+ imagesBuildCmd.Flags().StringVar(&buildNetwork, "network", "", "Build network mode")
+ imagesBuildCmd.Flags().StringVar(&buildProvider, "provider", "", "Build provider override")
+ imagesBuildCmd.Flags().BoolVar(&buildNoCache, "no-cache", false, "Disable build cache")
+ imagesBuildCmd.Flags().BoolVar(&buildPull, "pull", false, "Always pull referenced base images")
+ imagesBuildCmd.Flags().BoolVar(&buildPush, "push", false, "Push the image after building")
+ imagesBuildCmd.Flags().BoolVar(&buildLoad, "load", false, "Load the image into the local Docker daemon")
+
+ ImagesCmd.AddCommand(imagesBuildsCmd)
+ imagesBuildsCmd.Flags().IntVarP(&buildsLimit, "limit", "n", 0, "Number of builds to show (server default 20)")
+ imagesBuildsCmd.Flags().IntVar(&buildsStart, "start", 0, cmdutil.StartFlagUsage)
+ imagesBuildsCmd.Flags().BoolVarP(&buildsAll, "all", "a", false, cmdutil.AllFlagUsage)
+ imagesBuildsCmd.Flags().StringVar(&buildsStatus, "status", "", "Filter by status")
+ imagesBuildsCmd.Flags().StringVar(&buildsProvider, "provider", "", "Filter by provider")
+
+ imagesBuildsCmd.AddCommand(imagesBuildsGetCmd)
+}
diff --git a/cli/pkg/images/updates/cmd.go b/cli/pkg/images/updates/cmd.go
index c4d052c57..848cf79fc 100644
--- a/cli/pkg/images/updates/cmd.go
+++ b/cli/pkg/images/updates/cmd.go
@@ -3,6 +3,8 @@ package updates
import (
"encoding/json"
"fmt"
+ "net/http"
+ "sort"
"strconv"
"emperror.dev/errors"
@@ -21,10 +23,13 @@ var UpdatesCmd = &cobra.Command{
Short: "Check for image updates",
}
+var checkAll bool
+
var checkCmd = &cobra.Command{
- Use: "check <image-ref>",
- Short: "Check an image reference for updates",
- Args: cobra.ExactArgs(1),
+ Use: "check [image-ref...]",
+ Short: "Check image references for updates",
+ Long: "Check image references for updates.\n\nWith a single reference the update status is checked directly; with multiple references a batch check is performed. With --all every image is checked.",
+ Args: cobra.ArbitraryArgs,
SilenceUsage: true,
RunE: func(cmd *cobra.Command, args []string) error {
c, err := client.NewFromConfig()
@@ -32,7 +37,31 @@ var checkCmd = &cobra.Command{
return err
}
- resp, err := c.Get(cmd.Context(), types.Endpoints.ImageUpdatesCheck(c.EnvID(), args[0]))
+ if checkAll {
+ if len(args) > 0 {
+ return errors.New("--all cannot be combined with image references")
+ }
+ // The handler declares a non-pointer Body, so an empty body is a 400.
+ resp, err := c.Post(cmd.Context(), types.ImageUpdatesCheckAll(c.EnvID()), imageupdate.CheckAllImagesRequest{})
+ if err != nil {
+ return errors.WrapIf(err, "failed to check all updates")
+ }
+ return printBatchResults(resp, "failed to check all updates")
+ }
+
+ if len(args) == 0 {
+ return errors.New("at least one image reference is required (or use --all)")
+ }
+
+ if len(args) > 1 {
+ resp, err := c.Post(cmd.Context(), types.ImageUpdatesCheckBatch(c.EnvID()), imageupdate.BatchImageUpdateRequest{ImageRefs: args})
+ if err != nil {
+ return errors.WrapIf(err, "failed to check updates")
+ }
+ return printBatchResults(resp, "failed to check updates")
+ }
+
+ resp, err := c.Get(cmd.Context(), types.ImageUpdatesCheck(c.EnvID(), args[0]))
if err != nil {
return errors.WrapIf(err, "failed to check updates")
}
@@ -67,6 +96,7 @@ var checkCmd = &cobra.Command{
var checkAllCmd = &cobra.Command{
Use: "check-all",
+ Hidden: true,
Short: "Check all images for updates",
SilenceUsage: true,
RunE: func(cmd *cobra.Command, args []string) error {
@@ -76,7 +106,7 @@ var checkAllCmd = &cobra.Command{
}
// The handler declares a non-pointer Body, so an empty body is a 400.
- resp, err := c.Post(cmd.Context(), types.Endpoints.ImageUpdatesCheckAll(c.EnvID()), imageupdate.CheckAllImagesRequest{})
+ resp, err := c.Post(cmd.Context(), types.ImageUpdatesCheckAll(c.EnvID()), imageupdate.CheckAllImagesRequest{})
if err != nil {
return errors.WrapIf(err, "failed to check all updates")
}
@@ -111,6 +141,7 @@ var checkAllCmd = &cobra.Command{
var checkImageCmd = &cobra.Command{
Use: "check-image <image-id>",
+ Hidden: true,
Short: "Check specific image for updates",
Args: cobra.ExactArgs(1),
SilenceUsage: true,
@@ -120,7 +151,7 @@ var checkImageCmd = &cobra.Command{
return err
}
- resp, err := c.Get(cmd.Context(), types.Endpoints.ImageUpdatesCheckById(c.EnvID(), args[0]))
+ resp, err := c.Get(cmd.Context(), types.ImageUpdatesCheckById(c.EnvID(), args[0]))
if err != nil {
return errors.WrapIf(err, "failed to check image update")
}
@@ -162,7 +193,7 @@ var summaryCmd = &cobra.Command{
return err
}
- resp, err := c.Get(cmd.Context(), types.Endpoints.ImageUpdatesSummary(c.EnvID()))
+ resp, err := c.Get(cmd.Context(), types.ImageUpdatesSummary(c.EnvID()))
if err != nil {
return errors.WrapIf(err, "failed to get summary")
}
@@ -190,8 +221,58 @@ var summaryCmd = &cobra.Command{
},
}
+// printBatchResults decodes a batch update-check response and prints every
+// requested reference, including up-to-date and failed checks.
+func printBatchResults(resp *http.Response, wrapMsg string) error {
+ result, err := client.DecodeResponseStrict[imageupdate.BatchResponse](resp)
+ if err != nil {
+ return errors.WrapIf(err, wrapMsg)
+ }
+
+ if jsonOutput {
+ resultBytes, err := json.MarshalIndent(result.Data, "", " ")
+ if err != nil {
+ return errors.WrapIf(err, "failed to marshal JSON")
+ }
+ fmt.Println(string(resultBytes))
+ return nil
+ }
+
+ refs := make([]string, 0, len(result.Data))
+ for imageRef := range result.Data {
+ refs = append(refs, imageRef)
+ }
+ sort.Strings(refs)
+
+ headers := []string{"IMAGE", "UPDATE", "CURRENT", "LATEST", "TYPE"}
+ rows := make([][]string, 0, len(refs))
+ updatesAvailable := 0
+ for _, imageRef := range refs {
+ update := result.Data[imageRef]
+ if update == nil {
+ rows = append(rows, []string{imageRef, "unknown", "", "", ""})
+ continue
+ }
+ if update.Error != "" {
+ rows = append(rows, []string{imageRef, "error", update.CurrentVersion, "", update.Error})
+ continue
+ }
+ if update.HasUpdate {
+ updatesAvailable++
+ rows = append(rows, []string{imageRef, "Yes", update.CurrentVersion, update.LatestVersion, update.UpdateType})
+ continue
+ }
+ rows = append(rows, []string{imageRef, "No", update.CurrentVersion, "", ""})
+ }
+
+ output.Table(headers, rows)
+ fmt.Printf("\nTotal: %d images checked, %d updates available\n", len(result.Data), updatesAvailable)
+ return nil
+}
+
func init() {
UpdatesCmd.AddCommand(checkCmd)
+ checkCmd.Flags().BoolVar(&checkAll, "all", false, "Check every image for updates")
UpdatesCmd.AddCommand(checkAllCmd)
UpdatesCmd.AddCommand(checkImageCmd)
UpdatesCmd.AddCommand(summaryCmd)
diff --git a/cli/pkg/jobs/cmd.go b/cli/pkg/jobs/cmd.go
index ef82955bd..e9e2bdb2f 100644
--- a/cli/pkg/jobs/cmd.go
+++ b/cli/pkg/jobs/cmd.go
@@ -3,6 +3,8 @@ package jobs
import (
"encoding/json"
"fmt"
+ "strconv"
+ "time"
"emperror.dev/errors"
@@ -34,7 +36,7 @@ var getCmd = &cobra.Command{
return err
}
- resp, err := c.Get(cmd.Context(), types.Endpoints.JobSchedules(c.EnvID()))
+ resp, err := c.Get(cmd.Context(), types.JobSchedules(c.EnvID()))
if err != nil {
return errors.WrapIf(err, "failed to get job schedules")
}
@@ -96,7 +98,7 @@ var updateCmd = &cobra.Command{
return errors.New("no updates provided (set at least one interval flag)")
}
- resp, err := c.Put(cmd.Context(), types.Endpoints.JobSchedules(c.EnvID()), req)
+ resp, err := c.Put(cmd.Context(), types.JobSchedules(c.EnvID()), req)
if err != nil {
return errors.WrapIf(err, "failed to update job schedules")
}
@@ -124,12 +126,105 @@ var updateCmd = &cobra.Command{
},
}
+var listCmd = &cobra.Command{
+ Use: "list",
+ Aliases: []string{"ls"},
+ Short: "List background jobs",
+ SilenceUsage: true,
+ RunE: func(cmd *cobra.Command, args []string) error {
+ c, err := cmdutil.ClientFromCommand(cmd)
+ if err != nil {
+ return err
+ }
+
+ resp, err := c.Get(cmd.Context(), types.Jobs(c.EnvID()))
+ if err != nil {
+ return errors.WrapIf(err, "failed to list jobs")
+ }
+ defer func() { _ = resp.Body.Close() }()
+ if err := cmdutil.EnsureSuccessStatus(resp); err != nil {
+ return errors.WrapIf(err, "failed to list jobs")
+ }
+
+ var result jobschedule.JobListResponse
+ if err := cmdutil.DecodeJSON(resp, &result); err != nil {
+ return err
+ }
+
+ if jsonOutput {
+ return cmdutil.PrintJSON(result)
+ }
+
+ headers := []string{"ID", "NAME", "CATEGORY", "SCHEDULE", "NEXT RUN", "ENABLED"}
+ rows := make([][]string, len(result.Jobs))
+ for i, job := range result.Jobs {
+ nextRun := "-"
+ if job.NextRun != nil {
+ nextRun = job.NextRun.Format(time.RFC3339)
+ }
+ rows[i] = []string{
+ job.ID,
+ job.Name,
+ job.Category,
+ job.Schedule,
+ nextRun,
+ strconv.FormatBool(job.Enabled),
+ }
+ }
+
+ output.Table(headers, rows)
+ fmt.Printf("\nTotal: %d jobs\n", len(result.Jobs))
+ return nil
+ },
+}
+
+var runCmd = &cobra.Command{
+ Use: "run <job-id>",
+ Short: "Run a background job now",
+ Args: cobra.ExactArgs(1),
+ SilenceUsage: true,
+ RunE: func(cmd *cobra.Command, args []string) error {
+ c, err := cmdutil.ClientFromCommand(cmd)
+ if err != nil {
+ return err
+ }
+
+ resp, err := c.Post(cmd.Context(), types.JobRun(c.EnvID(), args[0]), nil)
+ if err != nil {
+ return errors.WrapIf(err, "failed to run job")
+ }
+ defer func() { _ = resp.Body.Close() }()
+ if err := cmdutil.EnsureSuccessStatus(resp); err != nil {
+ return errors.WrapIf(err, "failed to run job")
+ }
+
+ var result jobschedule.JobRunResponse
+ if err := cmdutil.DecodeJSON(resp, &result); err != nil {
+ return err
+ }
+
+ if jsonOutput {
+ return cmdutil.PrintJSON(result)
+ }
+
+ if !result.Success {
+ return errors.Errorf("job %s failed: %s", args[0], result.Message)
+ }
+ output.Success("%s", result.Message)
+ return nil
+ },
+}
+
func init() {
JobsCmd.AddCommand(getCmd)
JobsCmd.AddCommand(updateCmd)
+ JobsCmd.AddCommand(listCmd)
+ JobsCmd.AddCommand(runCmd)
getCmd.Flags().BoolVar(&jsonOutput, "json", false, "Output in JSON format")
updateCmd.Flags().BoolVar(&jsonOutput, "json", false, "Output in JSON format")
+ listCmd.Flags().BoolVar(&jsonOutput, "json", false, "Output in JSON format")
+ runCmd.Flags().BoolVar(&jsonOutput, "json", false, "Output in JSON format")
updateCmd.Flags().StringVar(&environmentHealthInterval, "environment-health-interval", "", "Environment health job interval (cron expression)")
updateCmd.Flags().StringVar(&eventCleanupInterval, "event-cleanup-interval", "", "Event cleanup job interval (cron expression)")
diff --git a/cli/pkg/networks/cmd.go b/cli/pkg/networks/cmd.go
index 301da5af8..e83c6153e 100644
--- a/cli/pkg/networks/cmd.go
+++ b/cli/pkg/networks/cmd.go
@@ -31,6 +31,27 @@ var (
unusedOnlyFlag bool
)
+var (
+ networkCreateName string
+ networkCreateDriver string
+ networkCreateSubnet string
+ networkCreateGateway string
+ networkCreateIPRange string
+ networkCreateInternal bool
+ networkCreateAttachable bool
+ networkCreateIPv6 bool
+ networkCreateLabels []string
+ networkCreateOpts []string
+)
+
+var (
+ connectAliases []string
+ connectIPv4 string
+ connectIPv6 string
+
+ disconnectForce bool
+)
+
const maxPromptOptions = 20
// NetworksCmd is the parent command for network operations
@@ -54,7 +75,7 @@ var listCmd = &cobra.Command{
return err
}
- path, err := cmdutil.ApplyPaginationParams(cmd, types.Endpoints.Networks(c.EnvID()), cmdutil.ListParams{
+ path, err := cmdutil.ApplyPaginationParams(cmd, types.Networks(c.EnvID()), cmdutil.ListParams{
Resource: "networks",
Limit: limitFlag,
FallbackDefault: 20,
@@ -134,7 +155,7 @@ var getCmd = &cobra.Command{
return err
}
- resp, err := c.Get(cmd.Context(), types.Endpoints.Network(c.EnvID(), resolvedID))
+ resp, err := c.Get(cmd.Context(), types.Network(c.EnvID(), resolvedID))
if err != nil {
return errors.WrapIf(err, "failed to get network")
}
@@ -206,7 +227,7 @@ var deleteCmd = &cobra.Command{
}
}
- resp, err := c.Delete(cmd.Context(), types.Endpoints.Network(c.EnvID(), resolvedID))
+ resp, err := c.Delete(cmd.Context(), types.Network(c.EnvID(), resolvedID))
if err != nil {
return errors.WrapIf(err, "failed to delete network")
}
@@ -243,7 +264,7 @@ var countsCmd = &cobra.Command{
return err
}
- resp, err := c.Get(cmd.Context(), types.Endpoints.NetworksCounts(c.EnvID()))
+ resp, err := c.Get(cmd.Context(), types.NetworksCounts(c.EnvID()))
if err != nil {
return errors.WrapIf(err, "failed to get network counts")
}
@@ -292,7 +313,7 @@ var pruneCmd = &cobra.Command{
return err
}
- resp, err := c.Post(cmd.Context(), types.Endpoints.NetworksPrune(c.EnvID()), nil)
+ resp, err := c.Post(cmd.Context(), types.NetworksPrune(c.EnvID()), nil)
if err != nil {
return errors.WrapIf(err, "failed to prune networks")
}
@@ -322,12 +343,262 @@ var pruneCmd = &cobra.Command{
},
}
+var createCmd = &cobra.Command{
+ Use: "create",
+ Short: "Create a network",
+ SilenceUsage: true,
+ RunE: func(cmd *cobra.Command, args []string) error {
+ c, err := client.NewFromConfig()
+ if err != nil {
+ return err
+ }
+
+ req := network.CreateRequest{
+ Name: networkCreateName,
+ Options: network.CreateOptions{
+ Driver: networkCreateDriver,
+ Internal: networkCreateInternal,
+ Attachable: networkCreateAttachable,
+ EnableIPv6: networkCreateIPv6,
+ },
+ }
+
+ if networkCreateSubnet != "" || networkCreateGateway != "" || networkCreateIPRange != "" {
+ req.Options.IPAM = &network.IPAM{
+ Config: []network.IPAMConfig{{
+ Subnet: networkCreateSubnet,
+ Gateway: networkCreateGateway,
+ IPRange: networkCreateIPRange,
+ }},
+ }
+ }
+
+ if len(networkCreateOpts) > 0 {
+ req.Options.Options = make(map[string]string)
+ for _, opt := range networkCreateOpts {
+ parts := strings.SplitN(opt, "=", 2)
+ if len(parts) == 2 {
+ req.Options.Options[parts[0]] = parts[1]
+ }
+ }
+ }
+
+ if len(networkCreateLabels) > 0 {
+ req.Options.Labels = make(map[string]string)
+ for _, lbl := range networkCreateLabels {
+ parts := strings.SplitN(lbl, "=", 2)
+ if len(parts) == 2 {
+ req.Options.Labels[parts[0]] = parts[1]
+ }
+ }
+ }
+
+ resp, err := c.Post(cmd.Context(), types.Networks(c.EnvID()), req)
+ if err != nil {
+ return errors.WrapIf(err, "failed to create network")
+ }
+ defer func() { _ = resp.Body.Close() }()
+ if err := cmdutil.EnsureSuccessStatus(resp); err != nil {
+ return errors.WrapIf(err, "failed to create network")
+ }
+
+ var result base.ApiResponse[network.CreateResponse]
+ if err := cmdutil.DecodeJSON(resp, &result); err != nil {
+ return err
+ }
+
+ if jsonOutput {
+ return cmdutil.PrintJSON(result.Data)
+ }
+
+ output.Success("Network %s created successfully", networkCreateName)
+ output.KeyValue("ID", result.Data.ID)
+ if result.Data.Warning != "" {
+ output.Warning("%s", result.Data.Warning)
+ }
+ return nil
+ },
+}
+
+var connectCmd = &cobra.Command{
+ Use: "connect <network-id|name> <container-id|name>",
+ Short: "Connect a container to a network",
+ Args: cobra.ExactArgs(2),
+ SilenceUsage: true,
+ RunE: func(cmd *cobra.Command, args []string) error {
+ c, err := client.NewFromConfig()
+ if err != nil {
+ return err
+ }
+
+ allowPrompt := !jsonOutput && prompt.IsInteractive()
+ resolvedID, resolvedName, err := resolveNetworkID(cmd.Context(), c, args[0], allowPrompt)
+ if err != nil {
+ return err
+ }
+
+ req := network.ConnectContainerRequest{
+ ContainerID: args[1],
+ Aliases: connectAliases,
+ IPv4Address: connectIPv4,
+ IPv6Address: connectIPv6,
+ }
+
+ resp, err := c.Post(cmd.Context(), types.NetworkConnect(c.EnvID(), resolvedID), req)
+ if err != nil {
+ return errors.WrapIf(err, "failed to connect container to network")
+ }
+ defer func() { _ = resp.Body.Close() }()
+ if err := cmdutil.EnsureSuccessStatus(resp); err != nil {
+ return errors.WrapIf(err, "failed to connect container to network")
+ }
+
+ var result base.ApiResponse[base.MessageResponse]
+ if err := cmdutil.DecodeJSON(resp, &result); err != nil {
+ return err
+ }
+
+ if jsonOutput {
+ return cmdutil.PrintJSON(result.Data)
+ }
+
+ display := resolvedName
+ if display == "" {
+ display = shortID(resolvedID)
+ }
+ output.Success("Container %s connected to network %s", args[1], display)
+ return nil
+ },
+}
+
+var disconnectCmd = &cobra.Command{
+ Use: "disconnect <network-id|name> <container-id|name>",
+ Short: "Disconnect a container from a network",
+ Args: cobra.ExactArgs(2),
+ SilenceUsage: true,
+ RunE: func(cmd *cobra.Command, args []string) error {
+ c, err := client.NewFromConfig()
+ if err != nil {
+ return err
+ }
+
+ allowPrompt := !jsonOutput && prompt.IsInteractive()
+ resolvedID, resolvedName, err := resolveNetworkID(cmd.Context(), c, args[0], allowPrompt)
+ if err != nil {
+ return err
+ }
+
+ req := network.DisconnectContainerRequest{
+ ContainerID: args[1],
+ Force: disconnectForce,
+ }
+
+ resp, err := c.Post(cmd.Context(), types.NetworkDisconnect(c.EnvID(), resolvedID), req)
+ if err != nil {
+ return errors.WrapIf(err, "failed to disconnect container from network")
+ }
+ defer func() { _ = resp.Body.Close() }()
+ if err := cmdutil.EnsureSuccessStatus(resp); err != nil {
+ return errors.WrapIf(err, "failed to disconnect container from network")
+ }
+
+ var result base.ApiResponse[base.MessageResponse]
+ if err := cmdutil.DecodeJSON(resp, &result); err != nil {
+ return err
+ }
+
+ if jsonOutput {
+ return cmdutil.PrintJSON(result.Data)
+ }
+
+ display := resolvedName
+ if display == "" {
+ display = shortID(resolvedID)
+ }
+ output.Success("Container %s disconnected from network %s", args[1], display)
+ return nil
+ },
+}
+
+var topologyCmd = &cobra.Command{
+ Use: "topology",
+ Short: "Show the network topology",
+ SilenceUsage: true,
+ RunE: func(cmd *cobra.Command, args []string) error {
+ c, err := client.NewFromConfig()
+ if err != nil {
+ return err
+ }
+
+ resp, err := c.Get(cmd.Context(), types.NetworksTopology(c.EnvID()))
+ if err != nil {
+ return errors.WrapIf(err, "failed to get network topology")
+ }
+ defer func() { _ = resp.Body.Close() }()
+
+ var result base.ApiResponse[network.Topology]
+ if err := cmdutil.DecodeJSON(resp, &result); err != nil {
+ return err
+ }
+
+ if jsonOutput {
+ return cmdutil.PrintJSON(result.Data)
+ }
+
+ nodeNames := make(map[string]string, len(result.Data.Nodes))
+ networkCount := 0
+ containerCount := 0
+ for _, node := range result.Data.Nodes {
+ name := node.Name
+ if name == "" {
+ name = shortID(node.ID)
+ }
+ nodeNames[node.ID] = name
+ switch node.Type {
+ case network.TopologyNodeTypeNetwork:
+ networkCount++
+ case network.TopologyNodeTypeContainer:
+ containerCount++
+ }
+ }
+
+ output.Header("Network Topology")
+ output.KeyValue("Networks", networkCount)
+ output.KeyValue("Containers", containerCount)
+ output.KeyValue("Connections", len(result.Data.Edges))
+
+ if len(result.Data.Edges) == 0 {
+ return nil
+ }
+
+ headers := []string{"NETWORK", "CONTAINER", "IPV4", "IPV6"}
+ rows := make([][]string, len(result.Data.Edges))
+ for i, edge := range result.Data.Edges {
+ source := nodeNames[edge.Source]
+ if source == "" {
+ source = shortID(edge.Source)
+ }
+ target := nodeNames[edge.Target]
+ if target == "" {
+ target = shortID(edge.Target)
+ }
+ rows[i] = []string{source, target, edge.IPv4Address, edge.IPv6Address}
+ }
+ output.Table(headers, rows)
+ return nil
+ },
+}
+
func init() {
NetworksCmd.AddCommand(listCmd)
NetworksCmd.AddCommand(getCmd)
NetworksCmd.AddCommand(deleteCmd)
NetworksCmd.AddCommand(countsCmd)
NetworksCmd.AddCommand(pruneCmd)
+ NetworksCmd.AddCommand(createCmd)
+ NetworksCmd.AddCommand(connectCmd)
+ NetworksCmd.AddCommand(disconnectCmd)
+ NetworksCmd.AddCommand(topologyCmd)
// List command flags
listCmd.Flags().IntVarP(&limitFlag, "limit", "n", 20, "Number of networks to show")
@@ -350,6 +621,33 @@ func init() {
// Counts command flags
countsCmd.Flags().BoolVar(&jsonOutput, "json", false, "Output in JSON format")
+
+ // Create command flags
+ createCmd.Flags().StringVar(&networkCreateName, "name", "", "Network name (required)")
+ createCmd.Flags().StringVar(&networkCreateDriver, "driver", "", "Network driver (e.g. bridge, overlay)")
+ createCmd.Flags().StringVar(&networkCreateSubnet, "subnet", "", "Subnet in CIDR format")
+ createCmd.Flags().StringVar(&networkCreateGateway, "gateway", "", "IPv4 or IPv6 gateway for the subnet")
+ createCmd.Flags().StringVar(&networkCreateIPRange, "ip-range", "", "Allocate container IPs from a sub-range")
+ createCmd.Flags().BoolVar(&networkCreateInternal, "internal", false, "Restrict external access to the network")
+ createCmd.Flags().BoolVar(&networkCreateAttachable, "attachable", false, "Allow manual container attachment")
+ createCmd.Flags().BoolVar(&networkCreateIPv6, "ipv6", false, "Enable IPv6 networking")
+ createCmd.Flags().StringArrayVar(&networkCreateLabels, "label", nil, "Label (KEY=VALUE)")
+ createCmd.Flags().StringArrayVar(&networkCreateOpts, "opt", nil, "Driver option (KEY=VALUE)")
+ createCmd.Flags().BoolVar(&jsonOutput, "json", false, "Output in JSON format")
+ _ = createCmd.MarkFlagRequired("name")
+
+ // Connect command flags
+ connectCmd.Flags().StringArrayVar(&connectAliases, "alias", nil, "Network-scoped alias for the container")
+ connectCmd.Flags().StringVar(&connectIPv4, "ip", "", "Static IPv4 address")
+ connectCmd.Flags().StringVar(&connectIPv6, "ip6", "", "Static IPv6 address")
+ connectCmd.Flags().BoolVar(&jsonOutput, "json", false, "Output in JSON format")
+
+ // Disconnect command flags
+ disconnectCmd.Flags().BoolVarP(&disconnectForce, "force", "f", false, "Force the disconnect")
+ disconnectCmd.Flags().BoolVar(&jsonOutput, "json", false, "Output in JSON format")
+
+ // Topology command flags
+ topologyCmd.Flags().BoolVar(&jsonOutput, "json", false, "Output in JSON format")
}
func shortID(id string) string {
@@ -365,7 +663,7 @@ func resolveNetworkID(ctx context.Context, c *client.Client, identifier string,
return "", "", errors.New("network identifier is required")
}
- resp, err := c.Get(ctx, types.Endpoints.Network(c.EnvID(), trimmed))
+ resp, err := c.Get(ctx, types.Network(c.EnvID(), trimmed))
if err != nil {
return "", "", errors.WrapIff(err, "failed to resolve network %q", trimmed)
}
@@ -388,7 +686,7 @@ func resolveNetworkID(ctx context.Context, c *client.Client, identifier string,
return "", "", errors.Errorf("failed to resolve network %q (status %d): %s", trimmed, resp.StatusCode, strings.TrimSpace(string(body)))
}
- searchPath := fmt.Sprintf("%s?search=%s&limit=%d", types.Endpoints.Networks(c.EnvID()), url.QueryEscape(trimmed), cmdutil.ShowAllLimit)
+ searchPath := fmt.Sprintf("%s?search=%s&limit=%d", types.Networks(c.EnvID()), url.QueryEscape(trimmed), cmdutil.ShowAllLimit)
searchResp, err := c.Get(ctx, searchPath)
if err != nil {
return "", "", errors.WrapIf(err, "failed to search networks")
diff --git a/cli/pkg/projects/actions.go b/cli/pkg/projects/actions.go
new file mode 100644
index 000000000..1d7a827ec
--- /dev/null
+++ b/cli/pkg/projects/actions.go
@@ -0,0 +1,399 @@
+package projects
+
+import (
+ "encoding/json"
+ "fmt"
+ "io"
+ "net/http"
+ "net/url"
+ "os"
+ "path"
+ "strings"
+ "time"
+
+ "emperror.dev/errors"
+
+ "github.com/getarcaneapp/arcane/cli/v2/internal/client"
+ "github.com/getarcaneapp/arcane/cli/v2/internal/cmdutil"
+ "github.com/getarcaneapp/arcane/cli/v2/internal/output"
+ "github.com/getarcaneapp/arcane/cli/v2/internal/types"
+ "github.com/getarcaneapp/arcane/types/v2/base"
+ "github.com/getarcaneapp/arcane/types/v2/project"
+ workspacetypes "github.com/getarcaneapp/arcane/types/v2/workspace"
+ "github.com/spf13/cobra"
+)
+
+var (
+ tagAdd string
+ tagRemove string
+ tagColor string
+
+ buildServices []string
+ buildProvider string
+ buildPush bool
+ buildLoad bool
+)
+
+var tagsCmd = &cobra.Command{
+ Use: "tags",
+ Short: "List project tags for the environment",
+ SilenceUsage: true,
+ RunE: func(cmd *cobra.Command, args []string) error {
+ c, err := client.NewFromConfig()
+ if err != nil {
+ return err
+ }
+
+ resp, err := c.Get(cmd.Context(), types.ProjectsTags(c.EnvID()))
+ if err != nil {
+ return errors.WrapIf(err, "failed to list project tags")
+ }
+ defer func() { _ = resp.Body.Close() }()
+ if err := cmdutil.EnsureSuccessStatus(resp); err != nil {
+ return errors.WrapIf(err, "failed to list project tags")
+ }
+
+ var result base.ApiResponse[[]project.TagOption]
+ if err := cmdutil.DecodeJSON(resp, &result); err != nil {
+ return err
+ }
+
+ if jsonOutput {
+ resultBytes, err := json.MarshalIndent(result.Data, "", " ")
+ if err != nil {
+ return errors.WrapIf(err, "failed to marshal JSON")
+ }
+ fmt.Println(string(resultBytes))
+ return nil
+ }
+
+ output.Header("Project Tags")
+ headers := []string{"NAME", "COLOR"}
+ rows := make([][]string, len(result.Data))
+ for i, tag := range result.Data {
+ rows[i] = []string{tag.Name, string(tag.Color)}
+ }
+ output.Table(headers, rows)
+ return nil
+ },
+}
+
+var tagCmd = &cobra.Command{
+ Use: "tag <project-id|name>",
+ Short: "Attach or detach a project tag",
+ Args: cobra.ExactArgs(1),
+ SilenceUsage: true,
+ RunE: func(cmd *cobra.Command, args []string) error {
+ if (tagAdd == "") == (tagRemove == "") {
+ return errors.New("exactly one of --add or --remove is required")
+ }
+ if tagRemove != "" && tagColor != "" {
+ return errors.New("--color can only be used with --add")
+ }
+
+ c, err := client.NewFromConfig()
+ if err != nil {
+ return err
+ }
+
+ resolved, _, err := resolveProject(cmd.Context(), c, args[0], false)
+ if err != nil {
+ return err
+ }
+
+ body := project.UpdateTag{
+ Name: tagAdd,
+ Attached: tagAdd != "",
+ Color: project.TagColor(tagColor),
+ }
+ if tagRemove != "" {
+ body.Name = tagRemove
+ }
+
+ resp, err := c.Request(cmd.Context(), http.MethodPatch, types.ProjectTags(c.EnvID(), resolved.ID), body)
+ if err != nil {
+ return errors.WrapIf(err, "failed to update project tag")
+ }
+ defer func() { _ = resp.Body.Close() }()
+ if err := cmdutil.EnsureSuccessStatus(resp); err != nil {
+ return errors.WrapIf(err, "failed to update project tag")
+ }
+
+ var result base.ApiResponse[project.UpdateTagResponse]
+ if err := cmdutil.DecodeJSON(resp, &result); err != nil {
+ return err
+ }
+
+ if jsonOutput {
+ resultBytes, err := json.MarshalIndent(result.Data, "", " ")
+ if err != nil {
+ return errors.WrapIf(err, "failed to marshal JSON")
+ }
+ fmt.Println(string(resultBytes))
+ return nil
+ }
+
+ names := make([]string, len(result.Data.Tags))
+ for i, tag := range result.Data.Tags {
+ names[i] = tag.Name
+ }
+ output.Success("Tags updated for project %s", resolved.Name)
+ output.KeyValue("Tags", strings.Join(names, ", "))
+ return nil
+ },
+}
+
+var archiveCmd = &cobra.Command{
+ Use: "archive <project-id|name>",
+ Short: "Archive a stopped project",
+ Args: cobra.ExactArgs(1),
+ SilenceUsage: true,
+ RunE: func(cmd *cobra.Command, args []string) error {
+ return runProjectPostAction(cmd, args[0], projectPostActionConfig{
+ endpoint: types.ProjectArchive,
+ failureMessage: "failed to archive project",
+ successMessage: "Project %s archived successfully",
+ })
+ },
+}
+
+var unarchiveCmd = &cobra.Command{
+ Use: "unarchive <project-id|name>",
+ Short: "Unarchive a project",
+ Args: cobra.ExactArgs(1),
+ SilenceUsage: true,
+ RunE: func(cmd *cobra.Command, args []string) error {
+ return runProjectPostAction(cmd, args[0], projectPostActionConfig{
+ endpoint: types.ProjectUnarchive,
+ failureMessage: "failed to unarchive project",
+ successMessage: "Project %s unarchived successfully",
+ })
+ },
+}
+
+var buildCmd = &cobra.Command{
+ Use: "build <project-id|name>",
+ Short: "Build project images",
+ Args: cobra.ExactArgs(1),
+ SilenceUsage: true,
+ RunE: func(cmd *cobra.Command, args []string) error {
+ c, err := client.NewFromConfig()
+ if err != nil {
+ return err
+ }
+
+ resolved, _, err := resolveProject(cmd.Context(), c, args[0], false)
+ if err != nil {
+ return err
+ }
+
+ c.SetTimeout(30 * time.Minute)
+
+ body := struct {
+ Services []string `json:"services,omitempty"`
+ Provider string `json:"provider,omitempty"`
+ Push *bool `json:"push,omitempty"`
+ Load *bool `json:"load,omitempty"`
+ }{Services: buildServices, Provider: buildProvider}
+ if cmd.Flags().Changed("push") {
+ body.Push = &buildPush
+ }
+ if cmd.Flags().Changed("load") {
+ body.Load = &buildLoad
+ }
+
+ resp, err := c.Post(cmd.Context(), types.ProjectBuild(c.EnvID(), resolved.ID), body)
+ if err != nil {
+ return errors.WrapIf(err, "failed to build project images")
+ }
+ defer func() { _ = resp.Body.Close() }()
+ if err := cmdutil.EnsureSuccessStatus(resp); err != nil {
+ return errors.WrapIf(err, "failed to build project images")
+ }
+
+ if err := printOperationStreamInternal(resp.Body); err != nil {
+ return errors.WrapIf(err, "failed to build project images")
+ }
+
+ output.Success("Images built successfully for project %s", resolved.Name)
+ return nil
+ },
+}
+
+var updateServicesCmd = &cobra.Command{
+ Use: "upgrade <project-id|name> [services...]",
+ Short: "Pull latest images and recreate services (all services when none are given)",
+ Args: cobra.MinimumNArgs(1),
+ SilenceUsage: true,
+ RunE: func(cmd *cobra.Command, args []string) error {
+ c, err := client.NewFromConfig()
+ if err != nil {
+ return err
+ }
+
+ resolved, _, err := resolveProject(cmd.Context(), c, args[0], false)
+ if err != nil {
+ return err
+ }
+
+ c.SetTimeout(30 * time.Minute)
+
+ body := struct {
+ Services []string `json:"services,omitempty"`
+ }{Services: args[1:]}
+
+ resp, err := c.Post(cmd.Context(), types.ProjectUpdateServices(c.EnvID(), resolved.ID), body)
+ if err != nil {
+ return errors.WrapIf(err, "failed to update project services")
+ }
+ defer func() { _ = resp.Body.Close() }()
+ if err := cmdutil.EnsureSuccessStatus(resp); err != nil {
+ return errors.WrapIf(err, "failed to update project services")
+ }
+
+ var result base.ApiResponse[base.MessageResponse]
+ if err := cmdutil.DecodeJSON(resp, &result); err != nil {
+ return err
+ }
+
+ if jsonOutput {
+ resultBytes, err := json.MarshalIndent(result.Data, "", " ")
+ if err != nil {
+ return errors.WrapIf(err, "failed to marshal JSON")
+ }
+ fmt.Println(string(resultBytes))
+ return nil
+ }
+
+ output.Success("Services updated successfully for project %s", resolved.Name)
+ return nil
+ },
+}
+
+var workspaceCmd = &cobra.Command{
+ Use: "workspace",
+ Short: "Work with project workspace files",
+}
+
+var workspaceCatCmd = &cobra.Command{
+ Use: "cat <project-id|name> <path>",
+ Short: "Print a project workspace file",
+ Args: cobra.ExactArgs(2),
+ SilenceUsage: true,
+ RunE: func(cmd *cobra.Command, args []string) error {
+ c, err := client.NewFromConfig()
+ if err != nil {
+ return err
+ }
+
+ resolved, _, err := resolveProject(cmd.Context(), c, args[0], false)
+ if err != nil {
+ return err
+ }
+
+ reqPath := types.ProjectWorkspaceFile(c.EnvID(), resolved.ID) + "?relativePath=" + url.QueryEscape(args[1])
+ resp, err := c.Get(cmd.Context(), reqPath)
+ if err != nil {
+ return errors.WrapIf(err, "failed to get workspace file")
+ }
+ defer func() { _ = resp.Body.Close() }()
+ if err := cmdutil.EnsureSuccessStatus(resp); err != nil {
+ return errors.WrapIf(err, "failed to get workspace file")
+ }
+
+ var result base.ApiResponse[workspacetypes.FileContent]
+ if err := cmdutil.DecodeJSON(resp, &result); err != nil {
+ return err
+ }
+
+ if jsonOutput {
+ resultBytes, err := json.MarshalIndent(result.Data, "", " ")
+ if err != nil {
+ return errors.WrapIf(err, "failed to marshal JSON")
+ }
+ fmt.Println(string(resultBytes))
+ return nil
+ }
+
+ if result.Data.Content == "" && result.Data.ReadOnlyReason != "" {
+ return errors.Errorf("file %s has no inline content (%s); use `arcane projects workspace download` instead", args[1], result.Data.ReadOnlyReason)
+ }
+ fmt.Print(result.Data.Content)
+ return nil
+ },
+}
+
+var workspaceDownloadCmd = &cobra.Command{
+ Use: "download <project-id|name> <path> [output-file]",
+ Short: "Download a project workspace file",
+ Args: cobra.RangeArgs(2, 3),
+ SilenceUsage: true,
+ RunE: func(cmd *cobra.Command, args []string) error {
+ c, err := client.NewFromConfig()
+ if err != nil {
+ return err
+ }
+
+ resolved, _, err := resolveProject(cmd.Context(), c, args[0], false)
+ if err != nil {
+ return err
+ }
+
+ reqPath := types.ProjectWorkspaceFileDownload(c.EnvID(), resolved.ID) + "?relativePath=" + url.QueryEscape(args[1])
+ resp, err := c.Get(cmd.Context(), reqPath)
+ if err != nil {
+ return errors.WrapIf(err, "failed to download workspace file")
+ }
+ defer func() { _ = resp.Body.Close() }()
+ if err := cmdutil.EnsureSuccessStatus(resp); err != nil {
+ return errors.WrapIf(err, "failed to download workspace file")
+ }
+
+ outputFile := path.Base(args[1])
+ if len(args) == 3 {
+ outputFile = args[2]
+ }
+
+ file, err := os.Create(outputFile)
+ if err != nil {
+ return errors.WrapIff(err, "failed to create file %s", outputFile)
+ }
+ written, copyErr := io.Copy(file, resp.Body)
+ closeErr := file.Close()
+ if copyErr != nil {
+ return errors.WrapIf(copyErr, "failed to write workspace file")
+ }
+ if closeErr != nil {
+ return errors.WrapIf(closeErr, "failed to write workspace file")
+ }
+
+ output.Success("Downloaded %s (%d bytes) to %s", args[1], written, outputFile)
+ return nil
+ },
+}
+
+func init() {
+ ProjectsCmd.AddCommand(tagsCmd)
+ ProjectsCmd.AddCommand(tagCmd)
+ ProjectsCmd.AddCommand(archiveCmd)
+ ProjectsCmd.AddCommand(unarchiveCmd)
+ ProjectsCmd.AddCommand(buildCmd)
+ ProjectsCmd.AddCommand(updateServicesCmd)
+ ProjectsCmd.AddCommand(workspaceCmd)
+ workspaceCmd.AddCommand(workspaceCatCmd)
+ workspaceCmd.AddCommand(workspaceDownloadCmd)
+
+ tagCmd.Flags().StringVar(&tagAdd, "add", "", "Tag name to attach")
+ tagCmd.Flags().StringVar(&tagRemove, "remove", "", "Tag name to detach")
+ tagCmd.Flags().StringVar(&tagColor, "color", "", "Tag color (used with --add)")
+
+ buildCmd.Flags().StringArrayVar(&buildServices, "service", nil, "Service to build (repeatable; all services with build directives when omitted)")
+ buildCmd.Flags().StringVar(&buildProvider, "provider", "", "Build provider override")
+ buildCmd.Flags().BoolVar(&buildPush, "push", false, "Push built images")
+ buildCmd.Flags().BoolVar(&buildLoad, "load", false, "Load built images into Docker")
+
+ tagsCmd.Flags().BoolVar(&jsonOutput, "json", false, "Output in JSON format")
+ tagCmd.Flags().BoolVar(&jsonOutput, "json", false, "Output in JSON format")
+ updateServicesCmd.Flags().BoolVar(&jsonOutput, "json", false, "Output in JSON format")
+ workspaceCatCmd.Flags().BoolVar(&jsonOutput, "json", false, "Output in JSON format")
+}
diff --git a/cli/pkg/projects/cmd.go b/cli/pkg/projects/cmd.go
index 0b2173335..ee3da97ac 100644
--- a/cli/pkg/projects/cmd.go
+++ b/cli/pkg/projects/cmd.go
@@ -156,7 +156,7 @@ func runProjectsList(cmd *cobra.Command, forceHasUpdateFilter bool) error {
}
func buildProjectsListPath(cmd *cobra.Command, c *client.Client, forceHasUpdateFilter bool) (string, error) {
- path, err := cmdutil.ApplyPaginationParams(cmd, types.Endpoints.Projects(c.EnvID()), cmdutil.ListParams{
+ path, err := cmdutil.ApplyPaginationParams(cmd, types.Projects(c.EnvID()), cmdutil.ListParams{
Resource: "projects",
Limit: limitFlag,
FallbackDefault: 20,
@@ -235,7 +235,7 @@ var destroyCmd = &cobra.Command{
}
}
- resp, err := c.DeleteWithBody(cmd.Context(), types.Endpoints.ProjectDestroy(c.EnvID(), resolved.ID), project.Destroy{
+ resp, err := c.DeleteWithBody(cmd.Context(), types.ProjectDestroy(c.EnvID(), resolved.ID), project.Destroy{
RemoveFiles: &destroyRemoveFiles,
RemoveVolumes: destroyRemoveVolumes,
})
@@ -270,7 +270,7 @@ var getCmd = &cobra.Command{
}
if !complete {
- resp, err := c.Get(cmd.Context(), types.Endpoints.Project(c.EnvID(), resolved.ID))
+ resp, err := c.Get(cmd.Context(), types.Project(c.EnvID(), resolved.ID))
if err != nil {
return errors.WrapIf(err, "failed to get project")
}
@@ -309,7 +309,7 @@ var upCmd = &cobra.Command{
SilenceUsage: true,
RunE: func(cmd *cobra.Command, args []string) error {
return runProjectPostAction(cmd, args[0], projectPostActionConfig{
- endpoint: types.Endpoints.ProjectUp,
+ endpoint: types.ProjectUp,
failureMessage: "failed to start project",
successMessage: "Project %s started successfully",
timeout: 30 * time.Minute,
@@ -325,7 +325,7 @@ var downCmd = &cobra.Command{
SilenceUsage: true,
RunE: func(cmd *cobra.Command, args []string) error {
return runProjectPostAction(cmd, args[0], projectPostActionConfig{
- endpoint: types.Endpoints.ProjectDown,
+ endpoint: types.ProjectDown,
failureMessage: "failed to stop project",
successMessage: "Project %s stopped successfully",
})
@@ -339,7 +339,7 @@ var restartCmd = &cobra.Command{
SilenceUsage: true,
RunE: func(cmd *cobra.Command, args []string) error {
return runProjectPostAction(cmd, args[0], projectPostActionConfig{
- endpoint: types.Endpoints.ProjectRestart,
+ endpoint: types.ProjectRestart,
failureMessage: "failed to restart project",
successMessage: "Project %s restarted successfully",
})
@@ -353,7 +353,7 @@ var redeployCmd = &cobra.Command{
SilenceUsage: true,
RunE: func(cmd *cobra.Command, args []string) error {
return runProjectPostAction(cmd, args[0], projectPostActionConfig{
- endpoint: types.Endpoints.ProjectRedeploy,
+ endpoint: types.ProjectRedeploy,
failureMessage: "failed to redeploy project",
successMessage: "Project %s redeployed successfully",
timeout: 30 * time.Minute,
@@ -369,7 +369,7 @@ var pullCmd = &cobra.Command{
SilenceUsage: true,
RunE: func(cmd *cobra.Command, args []string) error {
return runProjectPostAction(cmd, args[0], projectPostActionConfig{
- endpoint: types.Endpoints.ProjectPull,
+ endpoint: types.ProjectPull,
failureMessage: "failed to pull images",
successMessage: "Images pulled successfully for project %s",
timeout: 30 * time.Minute,
@@ -509,7 +509,7 @@ var createCmd = &cobra.Command{
return errors.WrapIf(err, "failed to finalize project request")
}
- resp, err := c.RequestRaw(cmd.Context(), http.MethodPost, types.Endpoints.Projects(c.EnvID()), &requestBody, map[string]string{"Content-Type": writer.FormDataContentType()})
+ resp, err := c.RequestRaw(cmd.Context(), http.MethodPost, types.Projects(c.EnvID()), &requestBody, map[string]string{"Content-Type": writer.FormDataContentType()})
if err != nil {
return errors.WrapIf(err, "failed to create project")
}
@@ -580,7 +580,7 @@ var updateCmd = &cobra.Command{
body.EnvContent = new(string(envBytes))
}
- resp, err := c.Put(cmd.Context(), types.Endpoints.Project(c.EnvID(), resolved.ID), body)
+ resp, err := c.Put(cmd.Context(), types.Project(c.EnvID(), resolved.ID), body)
if err != nil {
return errors.WrapIf(err, "failed to update project")
}
@@ -608,8 +608,9 @@ var updateCmd = &cobra.Command{
}
var updateIncludesCmd = &cobra.Command{
- Use: "update-includes <project-id|name>",
- Short: "Update an include file in a project",
+ Use: "update <project-id|name>",
+ Aliases: []string{"update-includes"},
+ Short: "Update an include file in a project workspace",
Args: cobra.ExactArgs(1),
SilenceUsage: true,
RunE: func(cmd *cobra.Command, args []string) error {
@@ -628,7 +629,7 @@ var updateIncludesCmd = &cobra.Command{
return errors.WrapIf(err, "failed to read include file")
}
- workspaceResponse, err := c.Get(cmd.Context(), types.Endpoints.ProjectWorkspace(c.EnvID(), resolved.ID))
+ workspaceResponse, err := c.Get(cmd.Context(), types.ProjectWorkspace(c.EnvID(), resolved.ID))
if err != nil {
return errors.WrapIf(err, "failed to get project workspace")
}
@@ -674,7 +675,7 @@ var updateIncludesCmd = &cobra.Command{
return errors.WrapIf(err, "failed to finalize workspace upload")
}
- resp, err := c.RequestRaw(cmd.Context(), http.MethodPut, types.Endpoints.ProjectWorkspace(c.EnvID(), resolved.ID), &requestBody, map[string]string{"Content-Type": writer.FormDataContentType()})
+ resp, err := c.RequestRaw(cmd.Context(), http.MethodPut, types.ProjectWorkspace(c.EnvID(), resolved.ID), &requestBody, map[string]string{"Content-Type": writer.FormDataContentType()})
if err != nil {
return errors.WrapIf(err, "failed to update include file")
}
@@ -711,7 +712,7 @@ var countsCmd = &cobra.Command{
return err
}
- resp, err := c.Get(cmd.Context(), types.Endpoints.ProjectsCounts(c.EnvID()))
+ resp, err := c.Get(cmd.Context(), types.ProjectsCounts(c.EnvID()))
if err != nil {
return errors.WrapIf(err, "failed to get project counts")
}
@@ -752,7 +753,7 @@ func init() {
ProjectsCmd.AddCommand(destroyCmd)
ProjectsCmd.AddCommand(createCmd)
ProjectsCmd.AddCommand(updateCmd)
- ProjectsCmd.AddCommand(updateIncludesCmd)
+ workspaceCmd.AddCommand(updateIncludesCmd)
// List command flags
listCmd.Flags().IntVarP(&limitFlag, "limit", "n", 20, "Number of projects to show")
@@ -805,7 +806,7 @@ func resolveProject(ctx context.Context, c *client.Client, identifier string, al
return nil, false, errors.New("project identifier is required")
}
- resp, err := c.Get(ctx, types.Endpoints.Project(c.EnvID(), trimmed))
+ resp, err := c.Get(ctx, types.Project(c.EnvID(), trimmed))
if err != nil {
return nil, false, errors.WrapIff(err, "failed to resolve project %q", trimmed)
}
@@ -830,7 +831,7 @@ func resolveProject(ctx context.Context, c *client.Client, identifier string, al
identifierLower := strings.ToLower(trimmed)
- searchPath := fmt.Sprintf("%s?search=%s&limit=%d", types.Endpoints.Projects(c.EnvID()), url.QueryEscape(trimmed), cmdutil.ShowAllLimit)
+ searchPath := fmt.Sprintf("%s?search=%s&limit=%d", types.Projects(c.EnvID()), url.QueryEscape(trimmed), cmdutil.ShowAllLimit)
searchResp, err := c.Get(ctx, searchPath)
if err != nil {
return nil, false, errors.WrapIf(err, "failed to search projects")
diff --git a/cli/pkg/registries/cmd.go b/cli/pkg/registries/cmd.go
index a33429c9e..a83638dd0 100644
--- a/cli/pkg/registries/cmd.go
+++ b/cli/pkg/registries/cmd.go
@@ -3,6 +3,7 @@ package registries
import (
"encoding/json"
"fmt"
+ "strconv"
"emperror.dev/errors"
@@ -57,7 +58,7 @@ var listCmd = &cobra.Command{
return err
}
- path := types.Endpoints.ContainerRegistries()
+ path := types.ContainerRegistries()
path, err = cmdutil.ApplyPaginationParams(cmd, path, cmdutil.ListParams{Resource: "registries", Limit: limitFlag, FallbackDefault: 20, Start: startFlag, All: allFlag})
if err != nil {
return errors.WrapIf(err, "failed to build pagination query")
@@ -120,7 +121,7 @@ var testCmd = &cobra.Command{
return err
}
- resp, err := c.Post(cmd.Context(), types.Endpoints.ContainerRegistryTest(args[0]), nil)
+ resp, err := c.Post(cmd.Context(), types.ContainerRegistryTest(args[0]), nil)
if err != nil {
return errors.WrapIf(err, "failed to test registry")
}
@@ -155,7 +156,7 @@ var getCmd = &cobra.Command{
return err
}
- resp, err := c.Get(cmd.Context(), types.Endpoints.ContainerRegistry(args[0]))
+ resp, err := c.Get(cmd.Context(), types.ContainerRegistry(args[0]))
if err != nil {
return errors.WrapIf(err, "failed to get registry")
}
@@ -214,7 +215,7 @@ var createCmd = &cobra.Command{
"awsRegion": registryCreateAWSRegion,
}
- resp, err := c.Post(cmd.Context(), types.Endpoints.ContainerRegistries(), req)
+ resp, err := c.Post(cmd.Context(), types.ContainerRegistries(), req)
if err != nil {
return errors.WrapIf(err, "failed to create registry")
}
@@ -305,7 +306,7 @@ var updateCmd = &cobra.Command{
return errors.New("no updates provided; use --url, --username, --password, --enabled, or --disabled")
}
- resp, err := c.Put(cmd.Context(), types.Endpoints.ContainerRegistry(args[0]), req)
+ resp, err := c.Put(cmd.Context(), types.ContainerRegistry(args[0]), req)
if err != nil {
return errors.WrapIf(err, "failed to update registry")
}
@@ -352,7 +353,7 @@ var deleteCmd = &cobra.Command{
return err
}
- resp, err := c.Delete(cmd.Context(), types.Endpoints.ContainerRegistry(args[0]))
+ resp, err := c.Delete(cmd.Context(), types.ContainerRegistry(args[0]))
if err != nil {
return errors.WrapIf(err, "failed to delete registry")
}
@@ -366,6 +367,69 @@ var deleteCmd = &cobra.Command{
},
}
+var usageCmd = &cobra.Command{
+ Use: "usage",
+ Aliases: []string{"pull-usage"},
+ Short: "Show pull usage and rate limits for configured registries",
+ SilenceUsage: true,
+ RunE: func(cmd *cobra.Command, args []string) error {
+ c, err := client.NewFromConfig()
+ if err != nil {
+ return err
+ }
+
+ resp, err := c.Get(cmd.Context(), types.ContainerRegistriesPullUsage())
+ if err != nil {
+ return errors.WrapIf(err, "failed to get registry pull usage")
+ }
+ defer func() { _ = resp.Body.Close() }()
+
+ var result base.ApiResponse[containerregistry.PullUsageResponse]
+ if err := cmdutil.DecodeJSON(resp, &result); err != nil {
+ return err
+ }
+
+ if jsonOutput {
+ resultBytes, err := json.MarshalIndent(result.Data, "", " ")
+ if err != nil {
+ return errors.WrapIf(err, "failed to marshal JSON")
+ }
+ fmt.Println(string(resultBytes))
+ return nil
+ }
+
+ if len(result.Data.Registries) == 0 {
+ output.Info("No registries configured")
+ return nil
+ }
+
+ formatCount := func(value *int) string {
+ if value == nil {
+ return "-"
+ }
+ return strconv.Itoa(*value)
+ }
+
+ headers := []string{"NAME", "REGISTRY", "PROVIDER", "LIMIT", "REMAINING", "USED", "OBSERVED", "CHECKED", "ERROR"}
+ rows := make([][]string, len(result.Data.Registries))
+ for i, usage := range result.Data.Registries {
+ rows[i] = []string{
+ usage.DisplayName,
+ usage.Registry,
+ usage.Provider,
+ formatCount(usage.Limit),
+ formatCount(usage.Remaining),
+ formatCount(usage.Used),
+ strconv.FormatInt(usage.ObservedPulls, 10),
+ usage.CheckedAt.Format("2006-01-02 15:04"),
+ usage.Error,
+ }
+ }
+ output.Table(headers, rows)
+ return nil
+ },
+}
+
func init() {
RegistriesCmd.AddCommand(listCmd)
RegistriesCmd.AddCommand(getCmd)
@@ -373,6 +437,7 @@ func init() {
RegistriesCmd.AddCommand(testCmd)
RegistriesCmd.AddCommand(updateCmd)
RegistriesCmd.AddCommand(deleteCmd)
+ RegistriesCmd.AddCommand(usageCmd)
listCmd.Flags().IntVarP(&limitFlag, "limit", "n", 20, "Number of registries to show")
listCmd.Flags().IntVar(&startFlag, "start", 0, cmdutil.StartFlagUsage)
@@ -405,4 +470,6 @@ func init() {
deleteCmd.Flags().BoolVarP(&forceFlag, "force", "f", false, "Force deletion without confirmation")
deleteCmd.Flags().BoolVar(&jsonOutput, "json", false, "Output in JSON format")
+
+ usageCmd.Flags().BoolVar(&jsonOutput, "json", false, "Output in JSON format")
}
diff --git a/cli/pkg/repos/cmd.go b/cli/pkg/repos/cmd.go
index e2950bf53..f036cf8a4 100644
--- a/cli/pkg/repos/cmd.go
+++ b/cli/pkg/repos/cmd.go
@@ -83,7 +83,7 @@ var listCmd = &cobra.Command{
return err
}
- path := types.Endpoints.GitRepositories()
+ path := types.GitRepositories()
path, err = cmdutil.ApplyPaginationParams(cmd, path, cmdutil.ListParams{Resource: "repos", Limit: limitFlag, FallbackDefault: 20, Start: startFlag, All: allFlag})
if err != nil {
return errors.WrapIf(err, "failed to build pagination query")
@@ -171,7 +171,7 @@ var createCmd = &cobra.Command{
req.Enabled = &repoCreateEnabled
}
- resp, err := c.Post(cmd.Context(), types.Endpoints.GitRepositories(), req)
+ resp, err := c.Post(cmd.Context(), types.GitRepositories(), req)
if err != nil {
return errors.WrapIf(err, "failed to create repository")
}
@@ -300,7 +300,7 @@ var updateCmd = &cobra.Command{
req.Enabled = &repoUpdateEnabled
}
- resp, err := c.Put(cmd.Context(), types.Endpoints.GitRepository(resolved.ID), req)
+ resp, err := c.Put(cmd.Context(), types.GitRepository(resolved.ID), req)
if err != nil {
return errors.WrapIf(err, "failed to update repository")
}
@@ -365,7 +365,7 @@ var deleteCmd = &cobra.Command{
}
}
- resp, err := c.Delete(cmd.Context(), types.Endpoints.GitRepository(resolved.ID))
+ resp, err := c.Delete(cmd.Context(), types.GitRepository(resolved.ID))
if err != nil {
return errors.WrapIf(err, "failed to delete repository")
}
@@ -395,7 +395,7 @@ var testCmd = &cobra.Command{
return err
}
- resp, err := c.Post(cmd.Context(), types.Endpoints.GitRepositoryTest(resolved.ID), nil)
+ resp, err := c.Post(cmd.Context(), types.GitRepositoryTest(resolved.ID), nil)
if err != nil {
return errors.WrapIf(err, "failed to test repository")
}
@@ -435,7 +435,7 @@ var branchesCmd = &cobra.Command{
return err
}
- resp, err := c.Get(cmd.Context(), types.Endpoints.GitRepositoryBranches(resolved.ID))
+ resp, err := c.Get(cmd.Context(), types.GitRepositoryBranches(resolved.ID))
if err != nil {
return errors.WrapIf(err, "failed to list branches")
}
@@ -490,7 +490,7 @@ var filesCmd = &cobra.Command{
return err
}
- path := types.Endpoints.GitRepositoryFiles(resolved.ID)
+ path := types.GitRepositoryFiles(resolved.ID)
params := url.Values{}
if filesBranch != "" {
params.Set("branch", filesBranch)
@@ -554,7 +554,7 @@ func resolveGitRepository(ctx context.Context, c *client.Client, identifier stri
}
// Try direct GET by ID.
- resp, err := c.Get(ctx, types.Endpoints.GitRepository(trimmed))
+ resp, err := c.Get(ctx, types.GitRepository(trimmed))
if err == nil {
defer func() { _ = resp.Body.Close() }()
if resp.StatusCode == http.StatusOK {
@@ -568,7 +568,7 @@ func resolveGitRepository(ctx context.Context, c *client.Client, identifier stri
}
// Fallback: search via list endpoint.
- listPath := cmdutil.AppendQuery(types.Endpoints.GitRepositories(), url.Values{"limit": []string{strconv.Itoa(cmdutil.ShowAllLimit)}})
+ listPath := cmdutil.AppendQuery(types.GitRepositories(), url.Values{"limit": []string{strconv.Itoa(cmdutil.ShowAllLimit)}})
listResp, err := c.Get(ctx, listPath)
if err != nil {
return nil, errors.WrapIf(err, "failed to search repositories")
diff --git a/cli/pkg/root.go b/cli/pkg/root.go
index 784e4f16b..cefd3f4dc 100644
--- a/cli/pkg/root.go
+++ b/cli/pkg/root.go
@@ -22,11 +22,13 @@
//
// - admin: Administration & platform management
// - auth: Authentication operations
+// - backups: Manage Arcane system backups
// - config: Manage CLI configuration
// - containers: Manage containers
// - images: Manage Docker images and updates
// - jobs: Manage background jobs
// - generate: Generate secrets and tokens
+// - variables: Manage global variables
// - version: Display version information
package cli
@@ -48,6 +50,7 @@ import (
runtimectx "github.com/getarcaneapp/arcane/cli/v2/internal/runtime"
"github.com/getarcaneapp/arcane/cli/v2/pkg/admin"
"github.com/getarcaneapp/arcane/cli/v2/pkg/auth"
+ "github.com/getarcaneapp/arcane/cli/v2/pkg/backups"
"github.com/getarcaneapp/arcane/cli/v2/pkg/completion"
configClient "github.com/getarcaneapp/arcane/cli/v2/pkg/config"
"github.com/getarcaneapp/arcane/cli/v2/pkg/containers"
@@ -66,6 +69,7 @@ import (
"github.com/getarcaneapp/arcane/cli/v2/pkg/system"
"github.com/getarcaneapp/arcane/cli/v2/pkg/templates"
"github.com/getarcaneapp/arcane/cli/v2/pkg/updater"
+ "github.com/getarcaneapp/arcane/cli/v2/pkg/variables"
"github.com/getarcaneapp/arcane/cli/v2/pkg/version"
"github.com/getarcaneapp/arcane/cli/v2/pkg/volumes"
"github.com/spf13/cobra"
@@ -268,6 +272,8 @@ func init() {
rootCmd.AddCommand(selfupdate.Cmd)
rootCmd.AddCommand(admin.AdminCmd)
rootCmd.AddCommand(gitops.GitopsCmd)
+ rootCmd.AddCommand(backups.BackupsCmd)
+ rootCmd.AddCommand(variables.VariablesCmd)
instrumentCommandTreeInternal(rootCmd)
}
diff --git a/cli/pkg/settings/cmd.go b/cli/pkg/settings/cmd.go
index 70f224f01..0edef72cc 100644
--- a/cli/pkg/settings/cmd.go
+++ b/cli/pkg/settings/cmd.go
@@ -30,7 +30,7 @@ var listCmd = &cobra.Command{
SilenceUsage: true,
RunE: func(cmd *cobra.Command, args []string) error {
return runSettingsList(cmd, settingsListConfig{
- endpoint: types.Endpoints.Settings,
+ endpoint: types.Settings,
failureMessage: "failed to get settings",
totalLabel: "settings",
})
@@ -59,7 +59,7 @@ var updateCmd = &cobra.Command{
return errors.WrapIf(err, "failed to parse settings file")
}
- resp, err := c.Put(cmd.Context(), types.Endpoints.Settings(c.EnvID()), req)
+ resp, err := c.Put(cmd.Context(), types.Settings(c.EnvID()), req)
if err != nil {
return errors.WrapIf(err, "failed to update settings")
}
@@ -89,7 +89,7 @@ var publicCmd = &cobra.Command{
SilenceUsage: true,
RunE: func(cmd *cobra.Command, args []string) error {
return runSettingsList(cmd, settingsListConfig{
- endpoint: types.Endpoints.SettingsPublic,
+ endpoint: types.SettingsPublic,
failureMessage: "failed to get public settings",
totalLabel: "public settings",
})
diff --git a/cli/pkg/system/cmd.go b/cli/pkg/system/cmd.go
index 4c38323e6..e8415ee92 100644
--- a/cli/pkg/system/cmd.go
+++ b/cli/pkg/system/cmd.go
@@ -4,6 +4,7 @@ import (
"encoding/json"
"fmt"
"strconv"
+ "time"
"emperror.dev/errors"
"github.com/getarcaneapp/arcane/cli/v2/internal/client"
@@ -41,7 +42,7 @@ var pruneCmd = &cobra.Command{
Networks: &system.PruneNetworksOptions{Mode: system.PruneNetworkModeUnused},
}
- resp, err := c.Post(cmd.Context(), types.Endpoints.SystemPrune(c.EnvID()), req)
+ resp, err := c.Post(cmd.Context(), types.SystemPrune(c.EnvID()), req)
if err != nil {
return errors.WrapIf(err, "failed to prune")
}
@@ -72,7 +73,8 @@ var pruneCmd = &cobra.Command{
}
var dockerInfoCmd = &cobra.Command{
- Use: "docker-info",
+ Use: "info",
+ Aliases: []string{"docker-info"},
Short: "Get Docker daemon information",
SilenceUsage: true,
RunE: func(cmd *cobra.Command, args []string) error {
@@ -81,7 +83,7 @@ var dockerInfoCmd = &cobra.Command{
return err
}
- resp, err := c.Get(cmd.Context(), types.Endpoints.SystemDockerInfo(c.EnvID()))
+ resp, err := c.Get(cmd.Context(), types.SystemDockerInfo(c.EnvID()))
if err != nil {
return errors.WrapIf(err, "failed to get docker info")
}
@@ -107,8 +109,15 @@ var dockerInfoCmd = &cobra.Command{
},
}
-var containersStartAllCmd = &cobra.Command{
- Use: "containers-start-all",
+var systemContainersCmd = &cobra.Command{
+ Use: "containers",
+ Short: "Bulk container operations",
+}
+
+var startStoppedOnlyFlag bool
+
+var containersStartCmd = &cobra.Command{
+ Use: "start",
Short: "Start all containers",
SilenceUsage: true,
RunE: func(cmd *cobra.Command, args []string) error {
@@ -117,23 +126,40 @@ var containersStartAllCmd = &cobra.Command{
return err
}
- resp, err := c.Post(cmd.Context(), types.Endpoints.SystemContainersStartAll(c.EnvID()), nil)
+ path := types.SystemContainersStartAll(c.EnvID())
+ if startStoppedOnlyFlag {
+ path = types.SystemStartStopped(c.EnvID())
+ }
+ resp, err := c.Post(cmd.Context(), path, nil)
if err != nil {
- return errors.WrapIf(err, "failed to start all containers")
+ return errors.WrapIf(err, "failed to start containers")
}
defer func() { _ = resp.Body.Close() }()
-
if err := cmdutil.EnsureSuccessStatus(resp); err != nil {
- return errors.WrapIf(err, "failed to start all containers")
+ return errors.WrapIf(err, "failed to start containers")
+ }
+
+ if jsonOutput {
+ var result base.ApiResponse[any]
+ if err := json.NewDecoder(resp.Body).Decode(&result); err == nil {
+ if resultBytes, err := json.MarshalIndent(result.Data, "", " "); err == nil {
+ fmt.Println(string(resultBytes))
+ }
+ }
+ return nil
}
- output.Success("Started all containers")
+ if startStoppedOnlyFlag {
+ output.Success("Started all stopped containers")
+ } else {
+ output.Success("Started all containers")
+ }
return nil
},
}
-var containersStopAllCmd = &cobra.Command{
- Use: "containers-stop-all",
+var containersStopCmd = &cobra.Command{
+ Use: "stop",
Short: "Stop all containers",
SilenceUsage: true,
RunE: func(cmd *cobra.Command, args []string) error {
@@ -142,7 +168,7 @@ var containersStopAllCmd = &cobra.Command{
return err
}
- resp, err := c.Post(cmd.Context(), types.Endpoints.SystemContainersStopAll(c.EnvID()), nil)
+ resp, err := c.Post(cmd.Context(), types.SystemContainersStopAll(c.EnvID()), nil)
if err != nil {
return errors.WrapIf(err, "failed to stop all containers")
}
@@ -157,40 +183,6 @@ var containersStopAllCmd = &cobra.Command{
},
}
-var startStoppedCmd = &cobra.Command{
- Use: "start-stopped",
- Short: "Start all stopped containers",
- SilenceUsage: true,
- RunE: func(cmd *cobra.Command, args []string) error {
- c, err := client.NewFromConfig()
- if err != nil {
- return err
- }
-
- resp, err := c.Post(cmd.Context(), types.Endpoints.SystemStartStopped(c.EnvID()), nil)
- if err != nil {
- return errors.WrapIf(err, "failed to start stopped containers")
- }
- defer func() { _ = resp.Body.Close() }()
- if err := cmdutil.EnsureSuccessStatus(resp); err != nil {
- return errors.WrapIf(err, "failed to start stopped containers")
- }
-
- if jsonOutput {
- var result base.ApiResponse[any]
- if err := json.NewDecoder(resp.Body).Decode(&result); err == nil {
- if resultBytes, err := json.MarshalIndent(result.Data, "", " "); err == nil {
- fmt.Println(string(resultBytes))
- }
- }
- return nil
- }
-
- output.Success("Started all stopped containers")
- return nil
- },
-}
-
var convertCmd = &cobra.Command{
Use: "convert <docker-run-command>",
Short: "Convert docker run command to compose",
@@ -203,7 +195,7 @@ var convertCmd = &cobra.Command{
}
req := map[string]string{"dockerRunCommand": args[0]}
- resp, err := c.Post(cmd.Context(), types.Endpoints.SystemConvert(c.EnvID()), req)
+ resp, err := c.Post(cmd.Context(), types.SystemConvert(c.EnvID()), req)
if err != nil {
return errors.WrapIf(err, "failed to convert command")
}
@@ -259,6 +251,19 @@ var upgradeCmd = &cobra.Command{
Short: "Trigger system upgrade",
SilenceUsage: true,
RunE: func(cmd *cobra.Command, args []string) error {
+ if upgradeAllStatusFlag && !upgradeAllFlag {
+ return errors.New("--status requires --all")
+ }
+ if upgradeCheckFlag && upgradeAllFlag {
+ return errors.New("--check cannot be combined with --all")
+ }
+ if upgradeAllFlag {
+ return runUpgradeAllInternal(cmd)
+ }
+ if upgradeCheckFlag {
+ return runUpgradeCheckInternal(cmd)
+ }
+
if !forceFlag {
confirmed, err := cmdutil.Confirm(cmd, "Are you sure you want to upgrade the system?")
if err != nil {
@@ -275,7 +280,7 @@ var upgradeCmd = &cobra.Command{
return err
}
- resp, err := c.Post(cmd.Context(), types.Endpoints.SystemUpgrade(c.EnvID()), nil)
+ resp, err := c.Post(cmd.Context(), types.SystemUpgrade(c.EnvID()), nil)
if err != nil {
return errors.WrapIf(err, "failed to upgrade system")
}
@@ -299,71 +304,197 @@ var upgradeCmd = &cobra.Command{
},
}
-var upgradeCheckCmd = &cobra.Command{
- Use: "upgrade-check",
- Short: "Check for available upgrades",
- SilenceUsage: true,
- RunE: func(cmd *cobra.Command, args []string) error {
- c, err := client.NewFromConfig()
+var upgradeCheckFlag bool
+
+func runUpgradeCheckInternal(cmd *cobra.Command) error {
+ c, err := client.NewFromConfig()
+ if err != nil {
+ return err
+ }
+
+ resp, err := c.Get(cmd.Context(), types.SystemUpgradeCheck(c.EnvID()))
+ if err != nil {
+ return errors.WrapIf(err, "failed to check for upgrades")
+ }
+ defer func() { _ = resp.Body.Close() }()
+
+ if err := cmdutil.EnsureSuccessStatus(resp); err != nil {
+ return errors.WrapIf(err, "failed to check for upgrades")
+ }
+
+ var result struct {
+ CanUpgrade bool `json:"canUpgrade"`
+ Error bool `json:"error"`
+ Message string `json:"message"`
+ }
+ if err := cmdutil.DecodeJSON(resp, &result); err != nil {
+ return err
+ }
+
+ if jsonOutput {
+ resultBytes, err := json.MarshalIndent(result, "", " ")
if err != nil {
- return err
+ return errors.WrapIf(err, "failed to marshal JSON")
}
+ fmt.Println(string(resultBytes))
+ return nil
+ }
+
+ output.Header("Upgrade Check")
+ output.KeyValue("Can Upgrade", strconv.FormatBool(result.CanUpgrade))
+ output.KeyValue("Message", result.Message)
+ if result.Error {
+ output.KeyValue("Error", "true")
+ }
+ return nil
+}
+
+// environmentUpdateJob mirrors the backend's fleet-wide update job payload
+// (backend/internal/system.EnvironmentUpdateJob), which is not exported in the
+// shared types module.
+type environmentUpdateJob struct {
+ ID string `json:"id"`
+ Status string `json:"status"`
+ Username string `json:"username"`
+ ManagerVersionAtStart string `json:"managerVersionAtStart"`
+ ManagerTargetVersion string `json:"managerTargetVersion"`
+ Results []struct {
+ EnvironmentID string `json:"environmentId"`
+ EnvironmentName string `json:"environmentName"`
+ Status string `json:"status"`
+ FromVersion string `json:"fromVersion,omitempty"`
+ ToVersion string `json:"toVersion,omitempty"`
+ Error string `json:"error,omitempty"`
+ } `json:"results,omitempty"`
+ Error *string `json:"error,omitempty"`
+ CompletedAt *time.Time `json:"completedAt,omitempty"`
+}
+
+func printUpdateAllJob(job environmentUpdateJob) {
+ output.KeyValue("Status", job.Status)
+ if job.Username != "" {
+ output.KeyValue("Triggered By", job.Username)
+ }
+ if job.ManagerVersionAtStart != "" {
+ output.KeyValue("Manager Version", job.ManagerVersionAtStart)
+ }
+ if job.ManagerTargetVersion != "" {
+ output.KeyValue("Target Version", job.ManagerTargetVersion)
+ }
+ if job.Error != nil && *job.Error != "" {
+ output.KeyValue("Error", *job.Error)
+ }
+ if job.CompletedAt != nil {
+ output.KeyValue("Completed At", job.CompletedAt.Format(time.RFC3339))
+ }
+ if len(job.Results) == 0 {
+ return
+ }
+
+ headers := []string{"ENVIRONMENT", "STATUS", "FROM", "TO", "ERROR"}
+ rows := make([][]string, len(job.Results))
+ for i, res := range job.Results {
+ name := res.EnvironmentName
+ if name == "" {
+ name = res.EnvironmentID
+ }
+ resErr := res.Error
+ if resErr == "" {
+ resErr = "-"
+ }
+ rows[i] = []string{name, res.Status, res.FromVersion, res.ToVersion, resErr}
+ }
+ fmt.Println()
+ output.Table(headers, rows)
+}
- resp, err := c.Get(cmd.Context(), types.Endpoints.SystemUpgradeCheck(c.EnvID()))
+var (
+ upgradeAllFlag bool
+ upgradeAllStatusFlag bool
+)
+
+func runUpgradeAllInternal(cmd *cobra.Command) error {
+ c, err := cmdutil.ClientFromCommand(cmd)
+ if err != nil {
+ return err
+ }
+
+ if upgradeAllStatusFlag {
+ resp, err := c.Get(cmd.Context(), types.SystemUpgradeAllStatus(c.EnvID()))
if err != nil {
- return errors.WrapIf(err, "failed to check for upgrades")
+ return errors.WrapIf(err, "failed to get update-all status")
}
defer func() { _ = resp.Body.Close() }()
-
if err := cmdutil.EnsureSuccessStatus(resp); err != nil {
- return errors.WrapIf(err, "failed to check for upgrades")
+ return errors.WrapIf(err, "failed to get update-all status")
}
- var result struct {
- CanUpgrade bool `json:"canUpgrade"`
- Error bool `json:"error"`
- Message string `json:"message"`
- }
+ var result base.ApiResponse[environmentUpdateJob]
if err := cmdutil.DecodeJSON(resp, &result); err != nil {
return err
}
if jsonOutput {
- resultBytes, err := json.MarshalIndent(result, "", " ")
- if err != nil {
- return errors.WrapIf(err, "failed to marshal JSON")
- }
- fmt.Println(string(resultBytes))
- return nil
+ return cmdutil.PrintJSON(result.Data)
}
- output.Header("Upgrade Check")
- output.KeyValue("Can Upgrade", strconv.FormatBool(result.CanUpgrade))
- output.KeyValue("Message", result.Message)
- if result.Error {
- output.KeyValue("Error", "true")
- }
+ output.Header("Update-All Status")
+ printUpdateAllJob(result.Data)
return nil
- },
+ }
+
+ if !forceFlag {
+ confirmed, err := cmdutil.Confirm(cmd, "Are you sure you want to update all environments?")
+ if err != nil {
+ return err
+ }
+ if !confirmed {
+ fmt.Println("Cancelled")
+ return nil
+ }
+ }
+
+ resp, err := c.Post(cmd.Context(), types.SystemUpgradeAll(c.EnvID()), nil)
+ if err != nil {
+ return errors.WrapIf(err, "failed to trigger update-all")
+ }
+ defer func() { _ = resp.Body.Close() }()
+ if err := cmdutil.EnsureSuccessStatus(resp); err != nil {
+ return errors.WrapIf(err, "failed to trigger update-all")
+ }
+
+ var result base.ApiResponse[environmentUpdateJob]
+ if err := cmdutil.DecodeJSON(resp, &result); err != nil {
+ return err
+ }
+
+ if jsonOutput {
+ return cmdutil.PrintJSON(result.Data)
+ }
+
+ output.Success("Update-all started")
+ printUpdateAllJob(result.Data)
+ return nil
}
func init() {
SystemCmd.AddCommand(pruneCmd)
SystemCmd.AddCommand(dockerInfoCmd)
- SystemCmd.AddCommand(containersStartAllCmd)
- SystemCmd.AddCommand(containersStopAllCmd)
- SystemCmd.AddCommand(startStoppedCmd)
+ SystemCmd.AddCommand(systemContainersCmd)
SystemCmd.AddCommand(convertCmd)
SystemCmd.AddCommand(upgradeCmd)
- SystemCmd.AddCommand(upgradeCheckCmd)
+ systemContainersCmd.AddCommand(containersStartCmd)
+ systemContainersCmd.AddCommand(containersStopCmd)
pruneCmd.Flags().BoolVar(&jsonOutput, "json", false, "Output in JSON format")
dockerInfoCmd.Flags().BoolVar(&jsonOutput, "json", false, "Output in JSON format")
- containersStartAllCmd.Flags().BoolVar(&jsonOutput, "json", false, "Output in JSON format")
- containersStopAllCmd.Flags().BoolVar(&jsonOutput, "json", false, "Output in JSON format")
- startStoppedCmd.Flags().BoolVar(&jsonOutput, "json", false, "Output in JSON format")
+ containersStartCmd.Flags().BoolVar(&jsonOutput, "json", false, "Output in JSON format")
+ containersStartCmd.Flags().BoolVar(&startStoppedOnlyFlag, "stopped", false, "Only start containers that are currently stopped")
+ containersStopCmd.Flags().BoolVar(&jsonOutput, "json", false, "Output in JSON format")
convertCmd.Flags().BoolVar(&jsonOutput, "json", false, "Output in JSON format")
upgradeCmd.Flags().BoolVarP(&forceFlag, "force", "f", false, "Skip confirmation")
upgradeCmd.Flags().BoolVar(&jsonOutput, "json", false, "Output in JSON format")
- upgradeCheckCmd.Flags().BoolVar(&jsonOutput, "json", false, "Output in JSON format")
+ upgradeCmd.Flags().BoolVar(&upgradeAllFlag, "all", false, "Update all environments with available updates")
+ upgradeCmd.Flags().BoolVar(&upgradeAllStatusFlag, "status", false, "Show the status of the latest update-all job (requires --all)")
+ upgradeCmd.Flags().BoolVar(&upgradeCheckFlag, "check", false, "Only check whether an upgrade is available")
}
diff --git a/cli/pkg/templates/cmd.go b/cli/pkg/templates/cmd.go
index 96b33053b..e09f3141e 100644
--- a/cli/pkg/templates/cmd.go
+++ b/cli/pkg/templates/cmd.go
@@ -22,7 +22,6 @@ import (
"github.com/getarcaneapp/arcane/cli/v2/internal/prompt"
"github.com/getarcaneapp/arcane/cli/v2/internal/types"
"github.com/getarcaneapp/arcane/types/v2/base"
- "github.com/getarcaneapp/arcane/types/v2/env"
"github.com/getarcaneapp/arcane/types/v2/template"
"github.com/spf13/cobra"
)
@@ -48,11 +47,6 @@ var (
templateDefaultsSaveFile string
templateDefaultsEnvFile string
templateFetchURL string
- templateVarsUpdateKey string
- templateVarsUpdateValue string
- templateVarsUpdateSecret bool
- templateVarsUpdateAllEnvs bool
- templateVarsUpdateEnvIDs []string
templateRegUpdateName string
templateRegUpdateURL string
templateRegUpdateDesc string
@@ -89,7 +83,7 @@ var listCmd = &cobra.Command{
if cmd.Flags().Changed("limit") || cmd.Flags().Changed("start") {
return errors.New("--all cannot be combined with explicit pagination flags")
}
- path = types.Endpoints.TemplatesAll()
+ path = types.TemplatesAll()
resp, err := c.Get(cmd.Context(), path)
if err != nil {
return errors.WrapIf(err, "failed to list templates")
@@ -105,7 +99,7 @@ var listCmd = &cobra.Command{
totalItems = int64(len(result.Data))
jsonPayload = result.Data
} else {
- path = types.Endpoints.Templates()
+ path = types.Templates()
path, err = cmdutil.ApplyPaginationParams(cmd, path, cmdutil.ListParams{Resource: "templates", Limit: limitFlag, FallbackDefault: 20, Start: startFlag})
if err != nil {
return errors.WrapIf(err, "failed to build pagination query")
@@ -171,7 +165,7 @@ var defaultCmd = &cobra.Command{
return err
}
- resp, err := c.Get(cmd.Context(), types.Endpoints.TemplatesDefault())
+ resp, err := c.Get(cmd.Context(), types.TemplatesDefault())
if err != nil {
return errors.WrapIf(err, "failed to get default templates")
}
@@ -209,7 +203,7 @@ var contentCmd = &cobra.Command{
return err
}
- resp, err := c.Get(cmd.Context(), types.Endpoints.TemplateContent(args[0]))
+ resp, err := c.Get(cmd.Context(), types.TemplateContent(args[0]))
if err != nil {
return errors.WrapIf(err, "failed to get template content")
}
@@ -255,7 +249,7 @@ var registriesCmd = &cobra.Command{
return err
}
- resp, err := c.Get(cmd.Context(), types.Endpoints.TemplatesRegistries())
+ resp, err := c.Get(cmd.Context(), types.TemplatesRegistries())
if err != nil {
return errors.WrapIf(err, "failed to list registries")
}
@@ -296,52 +290,34 @@ var registriesCmd = &cobra.Command{
},
}
-var variablesCmd = &cobra.Command{
- Use: "variables",
- Aliases: []string{"vars"},
- Short: "List global variables",
- SilenceUsage: true,
- RunE: func(cmd *cobra.Command, args []string) error {
- c, err := client.NewFromConfig()
+func runTemplateDelete(cmd *cobra.Command, label, path string) error {
+ if !forceFlag {
+ confirmed, err := cmdutil.Confirm(cmd, fmt.Sprintf("Are you sure you want to delete %s?", label))
if err != nil {
return err
}
-
- resp, err := c.Get(cmd.Context(), types.Endpoints.TemplatesVariables())
- if err != nil {
- return errors.WrapIf(err, "failed to list variables")
- }
- defer func() { _ = resp.Body.Close() }()
-
- var result base.ApiResponse[[]env.GlobalVariable]
- if err := cmdutil.DecodeJSON(resp, &result); err != nil {
- return errors.WrapIf(err, "failed to list variables")
+ if !confirmed {
+ fmt.Println("Cancelled")
+ return nil
}
+ }
- if jsonOutput {
- return cmdutil.PrintJSON(result.Data)
- }
+ c, err := client.NewFromConfig()
+ if err != nil {
+ return err
+ }
- headers := []string{"ID", "KEY", "VALUE", "SECRET", "SCOPE"}
- rows := make([][]string, len(result.Data))
- for i, v := range result.Data {
- scope := "all environments"
- if !v.AllEnvironments {
- scope = strings.Join(v.EnvironmentIDs, ", ")
- }
- rows[i] = []string{
- v.ID,
- v.Key,
- v.Value,
- strconv.FormatBool(v.IsSecret),
- scope,
- }
- }
+ resp, err := c.Delete(cmd.Context(), path)
+ if err != nil {
+ return errors.WrapIff(err, "failed to delete %s", label)
+ }
+ defer func() { _ = resp.Body.Close() }()
+ if err := cmdutil.EnsureSuccessStatus(resp); err != nil {
+ return errors.WrapIff(err, "failed to delete %s", label)
+ }
- output.Table(headers, rows)
- fmt.Printf("\nTotal: %d variables\n", len(result.Data))
- return nil
- },
+ output.Success("Deleted %s successfully", label)
+ return nil
}
var deleteCmd = &cobra.Command{
@@ -351,69 +327,18 @@ var deleteCmd = &cobra.Command{
Args: cobra.ExactArgs(1),
SilenceUsage: true,
RunE: func(cmd *cobra.Command, args []string) error {
- if !forceFlag {
- confirmed, err := cmdutil.Confirm(cmd, fmt.Sprintf("Are you sure you want to delete template %s?", args[0]))
- if err != nil {
- return err
- }
- if !confirmed {
- fmt.Println("Cancelled")
- return nil
- }
- }
-
- c, err := client.NewFromConfig()
- if err != nil {
- return err
- }
-
- resp, err := c.Delete(cmd.Context(), types.Endpoints.Template(args[0]))
- if err != nil {
- return errors.WrapIf(err, "failed to delete template")
- }
- defer func() { _ = resp.Body.Close() }()
- if err := cmdutil.EnsureSuccessStatus(resp); err != nil {
- return errors.WrapIf(err, "failed to delete template")
- }
-
- output.Success("Template deleted successfully")
- return nil
+ return runTemplateDelete(cmd, "template "+args[0], types.Template(args[0]))
},
}
var deleteRegistryCmd = &cobra.Command{
- Use: "delete-registry <registry-id>",
+ Use: "delete <registry-id>",
+ Aliases: []string{"rm", "remove"},
Short: "Delete template registry",
Args: cobra.ExactArgs(1),
SilenceUsage: true,
RunE: func(cmd *cobra.Command, args []string) error {
- if !forceFlag {
- confirmed, err := cmdutil.Confirm(cmd, fmt.Sprintf("Are you sure you want to delete template registry %s?", args[0]))
- if err != nil {
- return err
- }
- if !confirmed {
- fmt.Println("Cancelled")
- return nil
- }
- }
-
- c, err := client.NewFromConfig()
- if err != nil {
- return err
- }
-
- resp, err := c.Delete(cmd.Context(), types.Endpoints.TemplateRegistry(args[0]))
- if err != nil {
- return errors.WrapIf(err, "failed to delete registry")
- }
- defer func() { _ = resp.Body.Close() }()
- if err := cmdutil.EnsureSuccessStatus(resp); err != nil {
- return errors.WrapIf(err, "failed to delete registry")
- }
-
- output.Success("Template registry deleted successfully")
- return nil
+ return runTemplateDelete(cmd, "template registry "+args[0], types.TemplateRegistry(args[0]))
},
}
@@ -469,7 +394,7 @@ func resolveTemplate(ctx context.Context, c *client.Client, identifier string) (
return nil, errors.New("template identifier is required")
}
- resp, err := c.Get(ctx, types.Endpoints.Template(trimmed))
+ resp, err := c.Get(ctx, types.Template(trimmed))
if err != nil {
return nil, errors.WrapIf(err, "failed to get template")
}
@@ -488,7 +413,7 @@ func resolveTemplate(ctx context.Context, c *client.Client, identifier string) (
return nil, errors.Errorf("failed to get template: request failed with status %d: %s", resp.StatusCode, strings.TrimSpace(string(body)))
}
- listResp, err := c.Get(ctx, types.Endpoints.TemplatesAll())
+ listResp, err := c.Get(ctx, types.TemplatesAll())
if err != nil {
return nil, errors.WrapIf(err, "failed to search templates")
}
@@ -854,7 +779,7 @@ var createCmd = &cobra.Command{
return err
}
- resp, err := c.Post(cmd.Context(), types.Endpoints.Templates(), req)
+ resp, err := c.Post(cmd.Context(), types.Templates(), req)
if err != nil {
return errors.WrapIf(err, "failed to create template")
}
@@ -931,7 +856,7 @@ var updateCmd = &cobra.Command{
req.EnvContent = string(envContent)
}
- resp, err := c.Put(cmd.Context(), types.Endpoints.Template(args[0]), req)
+ resp, err := c.Put(cmd.Context(), types.Template(args[0]), req)
if err != nil {
return errors.WrapIf(err, "failed to update template")
}
@@ -964,7 +889,7 @@ var downloadCmd = &cobra.Command{
return err
}
- resp, err := c.Post(cmd.Context(), types.Endpoints.TemplateDownload(args[0]), nil)
+ resp, err := c.Post(cmd.Context(), types.TemplateDownload(args[0]), nil)
if err != nil {
return errors.WrapIf(err, "failed to download template")
}
@@ -996,7 +921,7 @@ var downloadCmd = &cobra.Command{
}
var defaultsSaveCmd = &cobra.Command{
- Use: "defaults-save",
+ Use: "save",
Short: "Save default templates",
SilenceUsage: true,
RunE: func(cmd *cobra.Command, args []string) error {
@@ -1022,7 +947,7 @@ var defaultsSaveCmd = &cobra.Command{
return err
}
- resp, err := c.Post(cmd.Context(), types.Endpoints.TemplatesDefault(), req)
+ resp, err := c.Post(cmd.Context(), types.TemplatesDefault(), req)
if err != nil {
return errors.WrapIf(err, "failed to save default templates")
}
@@ -1044,62 +969,8 @@ var defaultsSaveCmd = &cobra.Command{
},
}
-var variablesUpdateCmd = &cobra.Command{
- Use: "variables-update <variable-id>",
- Aliases: []string{"vars-update"},
- Short: "Update a global variable",
- Args: cobra.ExactArgs(1),
- SilenceUsage: true,
- RunE: func(cmd *cobra.Command, args []string) error {
- // Only the flags that were set are sent; every field on the request is a
- // pointer, and the server keeps the current value for the ones omitted.
- var req env.UpdateGlobalVariableRequest
- if cmd.Flags().Changed("key") {
- req.Key = &templateVarsUpdateKey
- }
- if cmd.Flags().Changed("value") {
- req.Value = &templateVarsUpdateValue
- }
- if cmd.Flags().Changed("secret") {
- req.IsSecret = &templateVarsUpdateSecret
- }
- if cmd.Flags().Changed("all-environments") {
- req.AllEnvironments = &templateVarsUpdateAllEnvs
- }
- if cmd.Flags().Changed("environment") {
- req.EnvironmentIDs = &templateVarsUpdateEnvIDs
- }
- if req.Key == nil && req.Value == nil && req.IsSecret == nil && req.AllEnvironments == nil && req.EnvironmentIDs == nil {
- return errors.New("no changes requested; pass at least one of --key, --value, --secret, --all-environments or --environment")
- }
-
- c, err := client.NewFromConfig()
- if err != nil {
- return err
- }
-
- resp, err := c.Put(cmd.Context(), types.Endpoints.Variable(args[0]), req)
- if err != nil {
- return errors.WrapIf(err, "failed to update variable")
- }
- defer func() { _ = resp.Body.Close() }()
-
- var result base.ApiResponse[env.GlobalVariableMutationResponse]
- if err := cmdutil.DecodeJSON(resp, &result); err != nil {
- return errors.WrapIf(err, "failed to update variable")
- }
-
- if jsonOutput {
- return cmdutil.PrintJSON(result.Data)
- }
-
- output.Success("Variable updated successfully")
- return nil
- },
-}
-
var registriesUpdateCmd = &cobra.Command{
- Use: "registries-update <registry-id>",
+ Use: "update <registry-id>",
Short: "Update a template registry",
Args: cobra.ExactArgs(1),
SilenceUsage: true,
@@ -1143,7 +1014,7 @@ var registriesUpdateCmd = &cobra.Command{
req.Enabled = false
}
- resp, err := c.Put(cmd.Context(), types.Endpoints.TemplateRegistry(args[0]), req)
+ resp, err := c.Put(cmd.Context(), types.TemplateRegistry(args[0]), req)
if err != nil {
return errors.WrapIf(err, "failed to update registry")
}
@@ -1168,7 +1039,7 @@ var registriesUpdateCmd = &cobra.Command{
// fetchTemplateInternal loads a single template, including its content.
func fetchTemplateInternal(cmd *cobra.Command, c *client.Client, id string) (template.Template, error) {
- resp, err := c.Get(cmd.Context(), types.Endpoints.Template(id))
+ resp, err := c.Get(cmd.Context(), types.Template(id))
if err != nil {
return template.Template{}, errors.WrapIf(err, "failed to load template")
}
@@ -1184,7 +1055,7 @@ func fetchTemplateInternal(cmd *cobra.Command, c *client.Client, id string) (tem
// fetchTemplateRegistryInternal looks a registry up by ID. The API exposes no
// get-by-id route for template registries, so this filters the list.
func fetchTemplateRegistryInternal(cmd *cobra.Command, c *client.Client, id string) (template.TemplateRegistry, error) {
- resp, err := c.Get(cmd.Context(), types.Endpoints.TemplatesRegistries())
+ resp, err := c.Get(cmd.Context(), types.TemplatesRegistries())
if err != nil {
return template.TemplateRegistry{}, errors.WrapIf(err, "failed to load registry")
}
@@ -1213,7 +1084,7 @@ var fetchCmd = &cobra.Command{
return err
}
- path := cmdutil.AppendQuery(types.Endpoints.TemplateFetch(), url.Values{"url": []string{templateFetchURL}})
+ path := cmdutil.AppendQuery(types.TemplateFetch(), url.Values{"url": []string{templateFetchURL}})
resp, err := c.Get(cmd.Context(), path)
if err != nil {
return errors.WrapIf(err, "failed to fetch templates")
@@ -1246,17 +1117,15 @@ func init() {
TemplatesCmd.AddCommand(defaultCmd)
TemplatesCmd.AddCommand(contentCmd)
TemplatesCmd.AddCommand(registriesCmd)
- TemplatesCmd.AddCommand(variablesCmd)
TemplatesCmd.AddCommand(deleteCmd)
- TemplatesCmd.AddCommand(deleteRegistryCmd)
TemplatesCmd.AddCommand(getCmd)
TemplatesCmd.AddCommand(createCmd)
TemplatesCmd.AddCommand(updateCmd)
TemplatesCmd.AddCommand(downloadCmd)
- TemplatesCmd.AddCommand(defaultsSaveCmd)
- TemplatesCmd.AddCommand(variablesUpdateCmd)
- TemplatesCmd.AddCommand(registriesUpdateCmd)
TemplatesCmd.AddCommand(fetchCmd)
+ defaultCmd.AddCommand(defaultsSaveCmd)
+ registriesCmd.AddCommand(registriesUpdateCmd)
+ registriesCmd.AddCommand(deleteRegistryCmd)
listCmd.Flags().IntVarP(&limitFlag, "limit", "n", 20, "Number of templates to show")
listCmd.Flags().IntVar(&startFlag, "start", 0, "Offset for pagination")
@@ -1265,7 +1134,6 @@ func init() {
defaultCmd.Flags().BoolVar(&jsonOutput, "json", false, "Output in JSON format")
contentCmd.Flags().BoolVar(&jsonOutput, "json", false, "Output in JSON format")
registriesCmd.Flags().BoolVar(&jsonOutput, "json", false, "Output in JSON format")
- variablesCmd.Flags().BoolVar(&jsonOutput, "json", false, "Output in JSON format")
deleteCmd.Flags().BoolVarP(&forceFlag, "force", "f", false, "Force deletion without confirmation")
deleteCmd.Flags().BoolVar(&jsonOutput, "json", false, "Output in JSON format")
@@ -1302,16 +1170,7 @@ func init() {
defaultsSaveCmd.Flags().BoolVar(&jsonOutput, "json", false, "Output in JSON format")
_ = defaultsSaveCmd.MarkFlagRequired("file")
- // variables-update command flags
- variablesUpdateCmd.Flags().StringVar(&templateVarsUpdateKey, "key", "", "New variable key")
- variablesUpdateCmd.Flags().StringVar(&templateVarsUpdateValue, "value", "", "New variable value")
- variablesUpdateCmd.Flags().BoolVar(&templateVarsUpdateSecret, "secret", false, "Mark the variable as a secret")
- variablesUpdateCmd.Flags().BoolVar(&templateVarsUpdateAllEnvs, "all-environments", false, "Scope the variable to all environments")
- variablesUpdateCmd.Flags().StringSliceVar(&templateVarsUpdateEnvIDs, "environment", nil, "Environment IDs to scope the variable to (repeatable)")
- variablesUpdateCmd.Flags().BoolVar(&jsonOutput, "json", false, "Output in JSON format")
- _ = variablesUpdateCmd.MarkFlagRequired("file")
-
- // registries-update command flags
+ // registries update command flags
registriesUpdateCmd.Flags().StringVar(&templateRegUpdateName, "name", "", "Registry name")
registriesUpdateCmd.Flags().StringVar(&templateRegUpdateURL, "url", "", "Registry URL")
registriesUpdateCmd.Flags().StringVar(&templateRegUpdateDesc, "description", "", "Registry description")
diff --git a/cli/pkg/updater/cmd.go b/cli/pkg/updater/cmd.go
index e678db1e1..f0e5281c7 100644
--- a/cli/pkg/updater/cmd.go
+++ b/cli/pkg/updater/cmd.go
@@ -39,7 +39,7 @@ var statusCmd = &cobra.Command{
return err
}
- resp, err := c.Get(cmd.Context(), types.Endpoints.UpdaterStatus(c.EnvID()))
+ resp, err := c.Get(cmd.Context(), types.UpdaterStatus(c.EnvID()))
if err != nil {
return errors.WrapIf(err, "failed to get updater status")
}
@@ -79,7 +79,7 @@ var runCmd = &cobra.Command{
// Updater run can take a long time as it pulls images and restarts containers
c.SetTimeout(30 * time.Minute)
- resp, err := c.Post(cmd.Context(), types.Endpoints.UpdaterRun(c.EnvID()), nil)
+ resp, err := c.Post(cmd.Context(), types.UpdaterRun(c.EnvID()), nil)
if err != nil {
return errors.WrapIf(err, "failed to run updater")
}
@@ -136,7 +136,7 @@ var historyCmd = &cobra.Command{
return err
}
- path := types.Endpoints.UpdaterHistory(c.EnvID())
+ path := types.UpdaterHistory(c.EnvID())
if cmd.Flags().Changed("limit") {
path = cmdutil.AppendQuery(path, url.Values{"limit": []string{strconv.Itoa(historyLimit)}})
}
diff --git a/cli/pkg/variables/cmd.go b/cli/pkg/variables/cmd.go
new file mode 100644
index 000000000..66062b8fb
--- /dev/null
+++ b/cli/pkg/variables/cmd.go
@@ -0,0 +1,353 @@
+package variables
+
+import (
+ "encoding/json"
+ "fmt"
+ "net/http"
+ "strconv"
+ "strings"
+ "time"
+
+ "emperror.dev/errors"
+
+ "github.com/getarcaneapp/arcane/cli/v2/internal/cmdutil"
+ "github.com/getarcaneapp/arcane/cli/v2/internal/output"
+ "github.com/getarcaneapp/arcane/cli/v2/internal/types"
+ "github.com/getarcaneapp/arcane/types/v2/base"
+ "github.com/getarcaneapp/arcane/types/v2/env"
+ "github.com/spf13/cobra"
+)
+
+var (
+ jsonOutput bool
+ forceFlag bool
+)
+
+var (
+ createKey string
+ createValue string
+ createSecret bool
+ createAllEnvs bool
+ createEnvIDs []string
+)
+
+var (
+ updateKey string
+ updateValue string
+ updateSecret bool
+ updateAllEnvs bool
+ updateEnvIDs []string
+)
+
+// VariablesCmd is the parent command for global variable operations.
+var VariablesCmd = &cobra.Command{
+ Use: "variables",
+ Aliases: []string{"variable", "vars"},
+ Short: "Manage global variables",
+}
+
+const secretMask = "********"
+
+func variableScope(allEnvironments bool, environmentIDs []string) string {
+ if allEnvironments {
+ return "all environments"
+ }
+ if len(environmentIDs) == 0 {
+ return "-"
+ }
+ return strings.Join(environmentIDs, ",")
+}
+
+func printSyncStatuses(statuses []env.EnvironmentSyncStatus) {
+ headers := []string{"ENVIRONMENT ID", "NAME", "STATUS", "LAST SYNCED", "ERROR"}
+ rows := make([][]string, len(statuses))
+ for i, status := range statuses {
+ lastSynced := "-"
+ if status.LastSyncedAt != nil {
+ lastSynced = status.LastSyncedAt.Format(time.RFC3339)
+ }
+ syncError := status.Error
+ if syncError == "" {
+ syncError = "-"
+ }
+ rows[i] = []string{
+ status.EnvironmentID,
+ status.EnvironmentName,
+ status.Status,
+ lastSynced,
+ syncError,
+ }
+ }
+ output.Table(headers, rows)
+}
+
+func printMutationResult(result env.GlobalVariableMutationResponse, message string) error {
+ if jsonOutput {
+ return cmdutil.PrintJSON(result)
+ }
+
+ output.Success("%s", message)
+ if result.Variable != nil {
+ output.KeyValue("ID", result.Variable.ID)
+ output.KeyValue("Key", result.Variable.Key)
+ output.KeyValue("Secret", strconv.FormatBool(result.Variable.IsSecret))
+ output.KeyValue("Scope", variableScope(result.Variable.AllEnvironments, result.Variable.EnvironmentIDs))
+ }
+ return nil
+}
+
+var listCmd = &cobra.Command{
+ Use: "list",
+ Aliases: []string{"ls"},
+ Short: "List global variables",
+ SilenceUsage: true,
+ RunE: func(cmd *cobra.Command, args []string) error {
+ c, err := cmdutil.ClientFromCommand(cmd)
+ if err != nil {
+ return err
+ }
+
+ resp, err := c.Get(cmd.Context(), types.Variables())
+ if err != nil {
+ return errors.WrapIf(err, "failed to list variables")
+ }
+ defer func() { _ = resp.Body.Close() }()
+ if err := cmdutil.EnsureSuccessStatus(resp); err != nil {
+ return errors.WrapIf(err, "failed to list variables")
+ }
+
+ body, err := cmdutil.ReadJSONBody(resp)
+ if err != nil {
+ return errors.WrapIf(err, "failed to list variables")
+ }
+
+ if jsonOutput {
+ return cmdutil.PrintRawJSON(body)
+ }
+
+ var result base.ApiResponse[[]env.GlobalVariable]
+ if err := json.Unmarshal(body, &result); err != nil {
+ return errors.WrapIf(err, "failed to parse response")
+ }
+
+ headers := []string{"ID", "KEY", "SCOPE", "SECRET", "VALUE"}
+ rows := make([][]string, len(result.Data))
+ for i, variable := range result.Data {
+ value := variable.Value
+ if variable.IsSecret {
+ value = secretMask
+ }
+ rows[i] = []string{
+ variable.ID,
+ variable.Key,
+ variableScope(variable.AllEnvironments, variable.EnvironmentIDs),
+ strconv.FormatBool(variable.IsSecret),
+ value,
+ }
+ }
+
+ output.Table(headers, rows)
+ fmt.Printf("\nTotal: %d variables\n", len(result.Data))
+ return nil
+ },
+}
+
+var createCmd = &cobra.Command{
+ Use: "create",
+ Short: "Create a global variable",
+ SilenceUsage: true,
+ RunE: func(cmd *cobra.Command, args []string) error {
+ c, err := cmdutil.ClientFromCommand(cmd)
+ if err != nil {
+ return err
+ }
+
+ req := env.CreateGlobalVariableRequest{
+ Key: createKey,
+ Value: createValue,
+ IsSecret: createSecret,
+ AllEnvironments: createAllEnvs,
+ EnvironmentIDs: createEnvIDs,
+ }
+
+ resp, err := c.Post(cmd.Context(), types.Variables(), req)
+ if err != nil {
+ return errors.WrapIf(err, "failed to create variable")
+ }
+ defer func() { _ = resp.Body.Close() }()
+ if err := cmdutil.EnsureSuccessStatus(resp); err != nil {
+ return errors.WrapIf(err, "failed to create variable")
+ }
+
+ var result base.ApiResponse[env.GlobalVariableMutationResponse]
+ if err := cmdutil.DecodeJSON(resp, &result); err != nil {
+ return err
+ }
+
+ return printMutationResult(result.Data, fmt.Sprintf("Variable %s created successfully", createKey))
+ },
+}
+
+var updateCmd = &cobra.Command{
+ Use: "update <id>",
+ Short: "Update a global variable",
+ Args: cobra.ExactArgs(1),
+ SilenceUsage: true,
+ RunE: func(cmd *cobra.Command, args []string) error {
+ c, err := cmdutil.ClientFromCommand(cmd)
+ if err != nil {
+ return err
+ }
+
+ var req env.UpdateGlobalVariableRequest
+ if cmd.Flags().Changed("key") {
+ req.Key = &updateKey
+ }
+ if cmd.Flags().Changed("value") {
+ req.Value = &updateValue
+ }
+ if cmd.Flags().Changed("secret") {
+ req.IsSecret = &updateSecret
+ }
+ if cmd.Flags().Changed("all-environments") {
+ req.AllEnvironments = &updateAllEnvs
+ }
+ if cmd.Flags().Changed("environment") {
+ req.EnvironmentIDs = &updateEnvIDs
+ }
+
+ if req.Key == nil && req.Value == nil && req.IsSecret == nil && req.AllEnvironments == nil && req.EnvironmentIDs == nil {
+ return errors.New("no updates provided (set at least one flag)")
+ }
+
+ resp, err := c.Put(cmd.Context(), types.Variable(args[0]), req)
+ if err != nil {
+ return errors.WrapIf(err, "failed to update variable")
+ }
+ defer func() { _ = resp.Body.Close() }()
+ if err := cmdutil.EnsureSuccessStatus(resp); err != nil {
+ return errors.WrapIf(err, "failed to update variable")
+ }
+
+ var result base.ApiResponse[env.GlobalVariableMutationResponse]
+ if err := cmdutil.DecodeJSON(resp, &result); err != nil {
+ return err
+ }
+
+ return printMutationResult(result.Data, "Variable updated successfully")
+ },
+}
+
+var deleteCmd = &cobra.Command{
+ Use: "delete <id>",
+ Aliases: []string{"rm", "remove"},
+ Short: "Delete a global variable",
+ Args: cobra.ExactArgs(1),
+ SilenceUsage: true,
+ RunE: func(cmd *cobra.Command, args []string) error {
+ if !forceFlag {
+ confirmed, err := cmdutil.Confirm(cmd, fmt.Sprintf("Are you sure you want to delete variable %s?", args[0]))
+ if err != nil {
+ return err
+ }
+ if !confirmed {
+ fmt.Println("Cancelled")
+ return nil
+ }
+ }
+
+ c, err := cmdutil.ClientFromCommand(cmd)
+ if err != nil {
+ return err
+ }
+
+ resp, err := c.Delete(cmd.Context(), types.Variable(args[0]))
+ if err != nil {
+ return errors.WrapIf(err, "failed to delete variable")
+ }
+ defer func() { _ = resp.Body.Close() }()
+ if err := cmdutil.EnsureSuccessStatus(resp); err != nil {
+ return errors.WrapIf(err, "failed to delete variable")
+ }
+
+ var result base.ApiResponse[env.GlobalVariableMutationResponse]
+ if err := cmdutil.DecodeJSON(resp, &result); err != nil {
+ return err
+ }
+
+ return printMutationResult(result.Data, "Variable deleted successfully")
+ },
+}
+
+var syncStatusFlag bool
+
+var syncCmd = &cobra.Command{
+ Use: "sync",
+ Short: "Sync global variables to every environment (--status shows the last sync result per environment)",
+ SilenceUsage: true,
+ RunE: func(cmd *cobra.Command, args []string) error {
+ c, err := cmdutil.ClientFromCommand(cmd)
+ if err != nil {
+ return err
+ }
+
+ var response *http.Response
+ failureMessage := "failed to sync variables"
+ if syncStatusFlag {
+ failureMessage = "failed to get variable sync status"
+ response, err = c.Get(cmd.Context(), types.VariablesSyncStatus())
+ } else {
+ response, err = c.Post(cmd.Context(), types.VariablesSync(), nil)
+ }
+ if err != nil {
+ return errors.WrapIff(err, "%s", failureMessage)
+ }
+ defer func() { _ = response.Body.Close() }()
+ if err := cmdutil.EnsureSuccessStatus(response); err != nil {
+ return errors.WrapIff(err, "%s", failureMessage)
+ }
+
+ var result base.ApiResponse[[]env.EnvironmentSyncStatus]
+ if err := cmdutil.DecodeJSON(response, &result); err != nil {
+ return err
+ }
+
+ if jsonOutput {
+ return cmdutil.PrintJSON(result.Data)
+ }
+
+ printSyncStatuses(result.Data)
+ return nil
+ },
+}
+
+func init() {
+ VariablesCmd.AddCommand(listCmd)
+ VariablesCmd.AddCommand(createCmd)
+ VariablesCmd.AddCommand(updateCmd)
+ VariablesCmd.AddCommand(deleteCmd)
+ VariablesCmd.AddCommand(syncCmd)
+
+ listCmd.Flags().BoolVar(&jsonOutput, "json", false, "Output in JSON format")
+
+ createCmd.Flags().StringVar(&createKey, "key", "", "Variable key")
+ createCmd.Flags().StringVar(&createValue, "value", "", "Variable value")
+ createCmd.Flags().BoolVar(&createSecret, "secret", false, "Store the value as a secret")
+ createCmd.Flags().BoolVar(&createAllEnvs, "all-environments", false, "Scope the variable to all environments")
+ createCmd.Flags().StringArrayVar(&createEnvIDs, "environment", nil, "Environment ID to scope the variable to (repeatable)")
+ createCmd.Flags().BoolVar(&jsonOutput, "json", false, "Output in JSON format")
+ _ = createCmd.MarkFlagRequired("key")
+
+ updateCmd.Flags().StringVar(&updateKey, "key", "", "Variable key")
+ updateCmd.Flags().StringVar(&updateValue, "value", "", "Variable value")
+ updateCmd.Flags().BoolVar(&updateSecret, "secret", false, "Store the value as a secret")
+ updateCmd.Flags().BoolVar(&updateAllEnvs, "all-environments", false, "Scope the variable to all environments")
+ updateCmd.Flags().StringArrayVar(&updateEnvIDs, "environment", nil, "Environment ID to scope the variable to (repeatable)")
+ updateCmd.Flags().BoolVar(&jsonOutput, "json", false, "Output in JSON format")
+
+ deleteCmd.Flags().BoolVarP(&forceFlag, "force", "f", false, "Skip the confirmation prompt")
+ deleteCmd.Flags().BoolVar(&jsonOutput, "json", false, "Output in JSON format")
+
+ syncCmd.Flags().BoolVar(&syncStatusFlag, "status", false, "Show the last sync result per environment instead of triggering a sync")
+ syncCmd.Flags().BoolVar(&jsonOutput, "json", false, "Output in JSON format")
+}
diff --git a/cli/pkg/version/cmd.go b/cli/pkg/version/cmd.go
index 117687e17..7d98b55c4 100644
--- a/cli/pkg/version/cmd.go
+++ b/cli/pkg/version/cmd.go
@@ -30,8 +30,8 @@ var VersionCmd = &cobra.Command{
// /api/version returns the trimmed version.Check payload, which carries
// neither displayVersion nor revision. /api/app-version returns the full
// version.Info, including the update-check fields printed below.
- logger.GetLogger().Debug("Sending request", "endpoint", clitypes.Endpoints.AppVersionEndpoint)
- resp, err := c.Get(cmd.Context(), clitypes.Endpoints.AppVersionEndpoint)
+ logger.GetLogger().Debug("Sending request", "endpoint", clitypes.AppVersionEndpoint)
+ resp, err := c.Get(cmd.Context(), clitypes.AppVersionEndpoint)
if err != nil {
return errors.WrapIf(err, "failed to get version")
}
diff --git a/cli/pkg/volumes/backup.go b/cli/pkg/volumes/backup.go
new file mode 100644
index 000000000..46bf9cabe
--- /dev/null
+++ b/cli/pkg/volumes/backup.go
@@ -0,0 +1,831 @@
+package volumes
+
+import (
+ "encoding/json"
+ "fmt"
+ "io"
+ "mime"
+ "net/http"
+ "os"
+ "strconv"
+ "time"
+
+ "emperror.dev/errors"
+
+ "github.com/getarcaneapp/arcane/cli/v2/internal/client"
+ "github.com/getarcaneapp/arcane/cli/v2/internal/cmdutil"
+ "github.com/getarcaneapp/arcane/cli/v2/internal/output"
+ "github.com/getarcaneapp/arcane/cli/v2/internal/prompt"
+ "github.com/getarcaneapp/arcane/cli/v2/internal/types"
+ "github.com/getarcaneapp/arcane/types/v2/base"
+ uploadtypes "github.com/getarcaneapp/arcane/types/v2/upload"
+ "github.com/getarcaneapp/arcane/types/v2/volume"
+ "github.com/spf13/cobra"
+)
+
+var (
+ backupCreateDestination string
+ backupCreateS3Destination string
+ backupCreatePolicyID string
+ backupUploadS3Destination string
+ restorePaths []string
+ restoreArchiveFile string
+)
+
+var (
+ policyEnabled bool
+ policySchedule string
+ policyRetention int
+ policyStopContainers bool
+ policyLocal bool
+ policyS3 bool
+ policyS3Destination string
+ policyID string
+ policyFile string
+)
+
+// backupsListResponse mirrors the backend's paginated volume backup response,
+// which carries warnings alongside the standard pagination envelope.
+type backupsListResponse struct {
+ Success bool `json:"success"`
+ Data []volume.BackupEntry `json:"data"`
+ Pagination base.PaginationResponse `json:"pagination"`
+ Warnings []string `json:"warnings,omitempty"`
+}
+
+var renameCmd = &cobra.Command{
+ Use: "rename <volume-name> <new-name>",
+ Short: "Rename an unused volume",
+ Args: cobra.ExactArgs(2),
+ SilenceUsage: true,
+ RunE: func(cmd *cobra.Command, args []string) error {
+ c, err := client.NewFromConfig()
+ if err != nil {
+ return err
+ }
+
+ allowPrompt := !forceFlag && !jsonOutput && prompt.IsInteractive()
+ resolved, err := resolveVolume(cmd.Context(), c, args[0], allowPrompt)
+ if err != nil {
+ return err
+ }
+
+ if !forceFlag {
+ confirmed, err := cmdutil.Confirm(cmd, fmt.Sprintf("Rename volume %s to %s? The volume is copied and the source is removed.", resolved.Name, args[1]))
+ if err != nil {
+ return err
+ }
+ if !confirmed {
+ fmt.Println("Cancelled")
+ return nil
+ }
+ }
+
+ resp, err := c.Post(cmd.Context(), types.VolumeRename(c.EnvID(), resolved.Name), volume.Rename{Name: args[1]})
+ if err != nil {
+ return errors.WrapIf(err, "failed to rename volume")
+ }
+ defer func() { _ = resp.Body.Close() }()
+ if err := cmdutil.EnsureSuccessStatus(resp); err != nil {
+ return errors.WrapIf(err, "failed to rename volume")
+ }
+
+ var result base.ApiResponse[volume.Volume]
+ if err := cmdutil.DecodeJSON(resp, &result); err != nil {
+ return err
+ }
+
+ if jsonOutput {
+ return cmdutil.PrintJSON(result.Data)
+ }
+
+ output.Success("Volume %s renamed to %s", resolved.Name, result.Data.Name)
+ return nil
+ },
+}
+
+var backupsPolicyCmd = &cobra.Command{
+ Use: "policy <volume-name>",
+ Short: "Show volume backup policies",
+ Args: cobra.ExactArgs(1),
+ SilenceUsage: true,
+ RunE: func(cmd *cobra.Command, args []string) error {
+ c, err := client.NewFromConfig()
+ if err != nil {
+ return err
+ }
+
+ allowPrompt := !jsonOutput && prompt.IsInteractive()
+ resolved, err := resolveVolume(cmd.Context(), c, args[0], allowPrompt)
+ if err != nil {
+ return err
+ }
+
+ resp, err := c.Get(cmd.Context(), types.VolumeBackupPolicy(c.EnvID(), resolved.Name))
+ if err != nil {
+ return errors.WrapIf(err, "failed to get backup policies")
+ }
+ defer func() { _ = resp.Body.Close() }()
+ if err := cmdutil.EnsureSuccessStatus(resp); err != nil {
+ return errors.WrapIf(err, "failed to get backup policies")
+ }
+
+ var result base.ApiResponse[volume.BackupPolicyCollection]
+ if err := cmdutil.DecodeJSON(resp, &result); err != nil {
+ return err
+ }
+
+ if jsonOutput {
+ return cmdutil.PrintJSON(result.Data)
+ }
+
+ printBackupPolicies(resolved.Name, result.Data)
+ return nil
+ },
+}
+
+var backupsPolicyUpdateCmd = &cobra.Command{
+ Use: "update <volume-name>",
+ Short: "Update volume backup policies",
+ Args: cobra.ExactArgs(1),
+ SilenceUsage: true,
+ RunE: func(cmd *cobra.Command, args []string) error {
+ c, err := client.NewFromConfig()
+ if err != nil {
+ return err
+ }
+
+ allowPrompt := !jsonOutput && prompt.IsInteractive()
+ resolved, err := resolveVolume(cmd.Context(), c, args[0], allowPrompt)
+ if err != nil {
+ return err
+ }
+
+ var payload volume.UpdateBackupPolicies
+ if policyFile != "" {
+ raw, err := os.ReadFile(policyFile)
+ if err != nil {
+ return errors.WrapIf(err, "failed to read policy file")
+ }
+ if err := json.Unmarshal(raw, &payload); err != nil {
+ return errors.WrapIf(err, "failed to parse policy file")
+ }
+ } else {
+ payload, err = buildPolicyUpdate(cmd, c, resolved.Name)
+ if err != nil {
+ return err
+ }
+ }
+
+ resp, err := c.Put(cmd.Context(), types.VolumeBackupPolicy(c.EnvID(), resolved.Name), payload)
+ if err != nil {
+ return errors.WrapIf(err, "failed to update backup policies")
+ }
+ defer func() { _ = resp.Body.Close() }()
+ if err := cmdutil.EnsureSuccessStatus(resp); err != nil {
+ return errors.WrapIf(err, "failed to update backup policies")
+ }
+
+ var result base.ApiResponse[volume.BackupPolicyCollection]
+ if err := cmdutil.DecodeJSON(resp, &result); err != nil {
+ return err
+ }
+
+ if jsonOutput {
+ return cmdutil.PrintJSON(result.Data)
+ }
+
+ output.Success("Backup policies for volume %s saved successfully", resolved.Name)
+ printBackupPolicies(resolved.Name, result.Data)
+ return nil
+ },
+}
+
+// buildPolicyUpdate merges the flag values into the volume's current policy
+// collection: the whole collection is PUT back, with only the targeted policy
+// changed. A new policy is appended when the volume has none yet.
+func buildPolicyUpdate(cmd *cobra.Command, c *client.Client, volumeName string) (volume.UpdateBackupPolicies, error) {
+ var payload volume.UpdateBackupPolicies
+
+ resp, err := c.Get(cmd.Context(), types.VolumeBackupPolicy(c.EnvID(), volumeName))
+ if err != nil {
+ return payload, errors.WrapIf(err, "failed to get current backup policies")
+ }
+ defer func() { _ = resp.Body.Close() }()
+ if err := cmdutil.EnsureSuccessStatus(resp); err != nil {
+ return payload, errors.WrapIf(err, "failed to get current backup policies")
+ }
+
+ var current base.ApiResponse[volume.BackupPolicyCollection]
+ if err := cmdutil.DecodeJSON(resp, &current); err != nil {
+ return payload, err
+ }
+
+ payload.Policies = make([]volume.UpdateBackupPolicy, len(current.Data.Policies))
+ targetIndex := -1
+ for i, p := range current.Data.Policies {
+ payload.Policies[i] = volume.UpdateBackupPolicy{
+ ID: p.ID,
+ Enabled: p.Enabled,
+ Schedule: p.Schedule,
+ RetentionCount: p.RetentionCount,
+ StopContainers: p.StopContainers,
+ LocalEnabled: p.LocalEnabled,
+ S3Enabled: p.S3Enabled,
+ S3DestinationID: p.S3DestinationID,
+ }
+ if policyID != "" && p.ID == policyID {
+ targetIndex = i
+ }
+ }
+
+ switch {
+ case policyID != "" && targetIndex == -1:
+ return payload, errors.Errorf("policy %q not found for volume %q", policyID, volumeName)
+ case policyID == "" && len(payload.Policies) > 1:
+ return payload, errors.Errorf("volume %q has %d backup policies; select one with --policy-id", volumeName, len(payload.Policies))
+ case policyID == "" && len(payload.Policies) == 1:
+ targetIndex = 0
+ case targetIndex == -1:
+ if policySchedule == "" {
+ return payload, errors.New("--schedule is required when creating a new backup policy")
+ }
+ // New policies default to local storage unless --local was set explicitly.
+ payload.Policies = append(payload.Policies, volume.UpdateBackupPolicy{LocalEnabled: !cmd.Flags().Changed("local") || policyLocal})
+ targetIndex = len(payload.Policies) - 1
+ }
+
+ target := &payload.Policies[targetIndex]
+ if cmd.Flags().Changed("enabled") {
+ target.Enabled = policyEnabled
+ }
+ if cmd.Flags().Changed("schedule") {
+ target.Schedule = policySchedule
+ }
+ if cmd.Flags().Changed("retention") {
+ target.RetentionCount = policyRetention
+ }
+ if cmd.Flags().Changed("stop-containers") {
+ target.StopContainers = policyStopContainers
+ }
+ if cmd.Flags().Changed("local") {
+ target.LocalEnabled = policyLocal
+ }
+ if cmd.Flags().Changed("s3") {
+ target.S3Enabled = policyS3
+ }
+ if cmd.Flags().Changed("s3-destination") {
+ target.S3DestinationID = policyS3Destination
+ }
+ return payload, nil
+}
+
+func printBackupPolicies(volumeName string, collection volume.BackupPolicyCollection) {
+ output.Header("Backup Policies: %s", volumeName)
+ output.KeyValue("S3 Available", collection.S3Available)
+ if len(collection.Policies) == 0 {
+ fmt.Println("No backup policies configured")
+ return
+ }
+
+ headers := []string{"ID", "ENABLED", "SCHEDULE", "RETENTION", "STOP CONTAINERS", "LOCAL", "S3", "S3 DESTINATION"}
+ rows := make([][]string, len(collection.Policies))
+ for i, p := range collection.Policies {
+ s3Destination := p.S3DestinationName
+ if s3Destination == "" {
+ s3Destination = p.S3DestinationID
+ }
+ rows[i] = []string{
+ p.ID,
+ output.TintEnabled(yesNo(p.Enabled)),
+ p.Schedule,
+ strconv.Itoa(p.RetentionCount),
+ yesNo(p.StopContainers),
+ yesNo(p.LocalEnabled),
+ yesNo(p.S3Enabled),
+ s3Destination,
+ }
+ }
+ output.Table(headers, rows)
+}
+
+func yesNo(v bool) string {
+ if v {
+ return "Yes"
+ }
+ return "No"
+}
+
+var backupsCmd = &cobra.Command{
+ Use: "backups <volume-name>",
+ Short: "Manage volume backups",
+ Args: cobra.ExactArgs(1),
+ SilenceUsage: true,
+ RunE: runListBackups,
+}
+
+var backupsListCmd = &cobra.Command{
+ Use: "list <volume-name>",
+ Aliases: []string{"ls"},
+ Short: "List volume backups",
+ Args: cobra.ExactArgs(1),
+ SilenceUsage: true,
+ RunE: runListBackups,
+}
+
+func runListBackups(cmd *cobra.Command, args []string) error {
+ c, err := client.NewFromConfig()
+ if err != nil {
+ return err
+ }
+
+ allowPrompt := !jsonOutput && prompt.IsInteractive()
+ resolved, err := resolveVolume(cmd.Context(), c, args[0], allowPrompt)
+ if err != nil {
+ return err
+ }
+
+ path, err := cmdutil.ApplyPaginationParams(cmd, types.VolumeBackups(c.EnvID(), resolved.Name), cmdutil.ListParams{
+ Resource: "backups",
+ Limit: limitFlag,
+ FallbackDefault: 20,
+ Start: startFlag,
+ All: allFlag,
+ })
+ if err != nil {
+ return errors.WrapIf(err, "failed to build pagination query")
+ }
+
+ resp, err := c.Get(cmd.Context(), path)
+ if err != nil {
+ return errors.WrapIf(err, "failed to list backups")
+ }
+ defer func() { _ = resp.Body.Close() }()
+
+ body, err := cmdutil.ReadJSONBody(resp)
+ if err != nil {
+ return errors.WrapIf(err, "failed to list backups")
+ }
+
+ if jsonOutput {
+ return cmdutil.PrintRawJSON(body)
+ }
+
+ var result backupsListResponse
+ if err := json.Unmarshal(body, &result); err != nil {
+ return errors.WrapIf(err, "failed to parse response")
+ }
+
+ headers := []string{"ID", "SIZE", "CREATED", "STATUS", "TRIGGER", "DESTINATION", "FORMAT"}
+ rows := make([][]string, len(result.Data))
+ for i, backup := range result.Data {
+ rows[i] = []string{
+ backup.ID,
+ output.Bytes(backup.Size),
+ backup.CreatedAt,
+ output.TintStatus(backup.Status),
+ backup.Trigger,
+ string(backup.Destination),
+ string(backup.Format),
+ }
+ }
+
+ output.Table(headers, rows)
+ output.Showing(len(result.Data), result.Pagination.TotalItems, "backups")
+ for _, warning := range result.Warnings {
+ output.Warning("%s", warning)
+ }
+ return nil
+}
+
+var backupsCreateCmd = &cobra.Command{
+ Use: "create <volume-name>",
+ Short: "Create a volume backup",
+ Args: cobra.ExactArgs(1),
+ SilenceUsage: true,
+ RunE: func(cmd *cobra.Command, args []string) error {
+ c, err := client.NewFromConfig()
+ if err != nil {
+ return err
+ }
+
+ allowPrompt := !jsonOutput && prompt.IsInteractive()
+ resolved, err := resolveVolume(cmd.Context(), c, args[0], allowPrompt)
+ if err != nil {
+ return err
+ }
+
+ req := volume.CreateBackupRequest{
+ Destination: volume.BackupDestination(backupCreateDestination),
+ PolicyID: backupCreatePolicyID,
+ S3DestinationID: backupCreateS3Destination,
+ }
+
+ resp, err := c.Post(cmd.Context(), types.VolumeBackups(c.EnvID(), resolved.Name), req)
+ if err != nil {
+ return errors.WrapIf(err, "failed to create backup")
+ }
+ defer func() { _ = resp.Body.Close() }()
+ if err := cmdutil.EnsureSuccessStatus(resp); err != nil {
+ return errors.WrapIf(err, "failed to create backup")
+ }
+
+ var result base.ApiResponse[volume.BackupEntry]
+ if err := cmdutil.DecodeJSON(resp, &result); err != nil {
+ return err
+ }
+
+ if jsonOutput {
+ return cmdutil.PrintJSON(result.Data)
+ }
+
+ output.Success("Backup created for volume %s", resolved.Name)
+ output.KeyValue("ID", result.Data.ID)
+ output.KeyValue("Status", result.Data.Status)
+ output.KeyValue("Destination", string(result.Data.Destination))
+ if result.Data.Size > 0 {
+ output.KeyValue("Size", output.Bytes(result.Data.Size))
+ }
+ return nil
+ },
+}
+
+var backupsRestoreCmd = &cobra.Command{
+ Use: "restore <volume-name> [backup-id]",
+ Short: "Restore a volume from a backup",
+ Long: `Restore a volume from an existing backup, or from a local tar.gz archive.
+
+With a backup ID the whole backup is restored; add one or more --path flags to
+restore only those paths. With --file a local tar.gz backup archive is uploaded
+and restored instead (no backup ID).`,
+ Args: cobra.RangeArgs(1, 2),
+ SilenceUsage: true,
+ RunE: func(cmd *cobra.Command, args []string) error {
+ if restoreArchiveFile != "" && len(args) == 2 {
+ return errors.New("--file and a backup ID are mutually exclusive")
+ }
+ if restoreArchiveFile == "" && len(args) < 2 {
+ return errors.New("a backup ID or --file is required")
+ }
+ if restoreArchiveFile != "" && len(restorePaths) > 0 {
+ return errors.New("--path cannot be used with --file")
+ }
+
+ c, err := client.NewFromConfig()
+ if err != nil {
+ return err
+ }
+
+ allowPrompt := !forceFlag && prompt.IsInteractive()
+ resolved, err := resolveVolume(cmd.Context(), c, args[0], allowPrompt)
+ if err != nil {
+ return err
+ }
+
+ if restoreArchiveFile != "" {
+ return runUploadRestore(cmd, c, resolved.Name)
+ }
+
+ backupID := args[1]
+ if len(restorePaths) > 0 {
+ return runRestorePaths(cmd, c, resolved.Name, backupID)
+ }
+
+ if !forceFlag {
+ confirmed, err := cmdutil.Confirm(cmd, fmt.Sprintf("Restore volume %s from backup %s? Current volume contents will be replaced.", resolved.Name, backupID))
+ if err != nil {
+ return err
+ }
+ if !confirmed {
+ fmt.Println("Cancelled")
+ return nil
+ }
+ }
+
+ resp, err := c.Post(cmd.Context(), types.VolumeBackupRestore(c.EnvID(), resolved.Name, backupID), nil)
+ if err != nil {
+ return errors.WrapIf(err, "failed to restore backup")
+ }
+ defer func() { _ = resp.Body.Close() }()
+ if err := cmdutil.EnsureSuccessStatus(resp); err != nil {
+ return errors.WrapIf(err, "failed to restore backup")
+ }
+
+ if jsonOutput {
+ body, err := cmdutil.ReadJSONBody(resp)
+ if err != nil {
+ return err
+ }
+ return cmdutil.PrintRawJSON(body)
+ }
+
+ output.Success("Restore of volume %s from backup %s initiated", resolved.Name, backupID)
+ return nil
+ },
+}
+
+func runRestorePaths(cmd *cobra.Command, c *client.Client, volumeName, backupID string) error {
+ if !forceFlag {
+ confirmed, err := cmdutil.Confirm(cmd, fmt.Sprintf("Restore %d path(s) into volume %s from backup %s?", len(restorePaths), volumeName, backupID))
+ if err != nil {
+ return err
+ }
+ if !confirmed {
+ fmt.Println("Cancelled")
+ return nil
+ }
+ }
+
+ body := struct {
+ Paths []string `json:"paths"`
+ }{Paths: restorePaths}
+
+ resp, err := c.Post(cmd.Context(), types.VolumeBackupRestoreFiles(c.EnvID(), volumeName, backupID), body)
+ if err != nil {
+ return errors.WrapIf(err, "failed to restore backup files")
+ }
+ defer func() { _ = resp.Body.Close() }()
+ if err := cmdutil.EnsureSuccessStatus(resp); err != nil {
+ return errors.WrapIf(err, "failed to restore backup files")
+ }
+
+ if jsonOutput {
+ respBody, err := cmdutil.ReadJSONBody(resp)
+ if err != nil {
+ return err
+ }
+ return cmdutil.PrintRawJSON(respBody)
+ }
+
+ output.Success("Restore of %d path(s) into volume %s initiated", len(restorePaths), volumeName)
+ return nil
+}
+
+func runUploadRestore(cmd *cobra.Command, c *client.Client, volumeName string) error {
+ if !forceFlag {
+ confirmed, err := cmdutil.Confirm(cmd, fmt.Sprintf("Restore volume %s from %s? Current volume contents will be replaced.", volumeName, restoreArchiveFile))
+ if err != nil {
+ return err
+ }
+ if !confirmed {
+ fmt.Println("Cancelled")
+ return nil
+ }
+ }
+
+ // Uploading and restoring large backups can take a long time
+ c.SetTimeout(30 * time.Minute)
+
+ sessionID, err := cmdutil.UploadFileInChunks(cmd.Context(), c, uploadtypes.KindVolumeBackup, restoreArchiveFile, !jsonOutput)
+ if err != nil {
+ return err
+ }
+
+ respBody, err := c.DoRaw(cmd.Context(), http.MethodPost, types.VolumeBackupUploadRestore(c.EnvID(), volumeName), uploadtypes.ConsumeRequest{UploadID: sessionID})
+ if err != nil {
+ cmdutil.AbortUploadSession(cmd.Context(), c, uploadtypes.KindVolumeBackup, sessionID)
+ return errors.WrapIf(err, "failed to upload and restore backup")
+ }
+
+ if jsonOutput {
+ fmt.Println(string(respBody))
+ return nil
+ }
+
+ output.Success("Backup uploaded and restored into volume %s successfully", volumeName)
+ return nil
+}
+
+var backupsDeleteCmd = &cobra.Command{
+ Use: "delete <backup-id>",
+ Aliases: []string{"rm", "remove"},
+ Short: "Delete a volume backup",
+ Args: cobra.ExactArgs(1),
+ SilenceUsage: true,
+ RunE: func(cmd *cobra.Command, args []string) error {
+ if !forceFlag {
+ confirmed, err := cmdutil.Confirm(cmd, fmt.Sprintf("Are you sure you want to delete backup %s?", args[0]))
+ if err != nil {
+ return err
+ }
+ if !confirmed {
+ fmt.Println("Cancelled")
+ return nil
+ }
+ }
+
+ c, err := client.NewFromConfig()
+ if err != nil {
+ return err
+ }
+
+ resp, err := c.Delete(cmd.Context(), types.VolumeBackup(c.EnvID(), args[0]))
+ if err != nil {
+ return errors.WrapIf(err, "failed to delete backup")
+ }
+ defer func() { _ = resp.Body.Close() }()
+ if err := cmdutil.EnsureSuccessStatus(resp); err != nil {
+ return errors.WrapIf(err, "failed to delete backup")
+ }
+
+ output.Success("Backup %s deleted successfully", args[0])
+ return nil
+ },
+}
+
+var backupsUploadCmd = &cobra.Command{
+ Use: "upload <backup-id>",
+ Short: "Upload an existing local backup to an S3 destination",
+ Args: cobra.ExactArgs(1),
+ SilenceUsage: true,
+ RunE: func(cmd *cobra.Command, args []string) error {
+ c, err := client.NewFromConfig()
+ if err != nil {
+ return err
+ }
+
+ // Uploading large backups can take a long time
+ c.SetTimeout(30 * time.Minute)
+
+ req := volume.UploadBackupRequest{S3DestinationID: backupUploadS3Destination}
+ resp, err := c.Post(cmd.Context(), types.VolumeBackupUpload(c.EnvID(), args[0]), req)
+ if err != nil {
+ return errors.WrapIf(err, "failed to upload backup")
+ }
+ defer func() { _ = resp.Body.Close() }()
+ if err := cmdutil.EnsureSuccessStatus(resp); err != nil {
+ return errors.WrapIf(err, "failed to upload backup")
+ }
+
+ var result base.ApiResponse[volume.BackupEntry]
+ if err := cmdutil.DecodeJSON(resp, &result); err != nil {
+ return err
+ }
+
+ if jsonOutput {
+ return cmdutil.PrintJSON(result.Data)
+ }
+
+ output.Success("Backup %s uploaded to S3 successfully", args[0])
+ return nil
+ },
+}
+
+var backupsDownloadCmd = &cobra.Command{
+ Use: "download <backup-id> [output-file]",
+ Short: "Download a volume backup archive",
+ Args: cobra.RangeArgs(1, 2),
+ SilenceUsage: true,
+ RunE: func(cmd *cobra.Command, args []string) error {
+ c, err := client.NewFromConfig()
+ if err != nil {
+ return err
+ }
+
+ // Downloading large backups can take a long time
+ c.SetTimeout(30 * time.Minute)
+
+ resp, err := c.Get(cmd.Context(), types.VolumeBackupDownload(c.EnvID(), args[0]))
+ if err != nil {
+ return errors.WrapIf(err, "failed to download backup")
+ }
+ defer func() { _ = resp.Body.Close() }()
+ if err := cmdutil.EnsureSuccessStatus(resp); err != nil {
+ return errors.WrapIf(err, "failed to download backup")
+ }
+
+ outputFile := ""
+ if len(args) == 2 {
+ outputFile = args[1]
+ }
+ if outputFile == "" {
+ outputFile = downloadFilename(resp, args[0]+".tar.gz")
+ }
+
+ if err := writeResponseToFile(resp.Body, outputFile); err != nil {
+ return err
+ }
+
+ output.Success("Backup downloaded to %s", outputFile)
+ return nil
+ },
+}
+
+// downloadFilename extracts the filename from the response's
+// Content-Disposition header, falling back to the given default.
+func downloadFilename(resp *http.Response, fallback string) string {
+ if _, params, err := mime.ParseMediaType(resp.Header.Get("Content-Disposition")); err == nil {
+ if name := params["filename"]; name != "" {
+ return name
+ }
+ }
+ return fallback
+}
+
+func writeResponseToFile(body io.Reader, path string) error {
+ file, err := os.OpenFile(path, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0o600)
+ if err != nil {
+ return errors.WrapIff(err, "failed to create file %s", path)
+ }
+ if _, err := io.Copy(file, body); err != nil {
+ _ = file.Close()
+ return errors.WrapIff(err, "failed to write file %s", path)
+ }
+ if err := file.Close(); err != nil {
+ return errors.WrapIff(err, "failed to write file %s", path)
+ }
+ return nil
+}
+
+var backupsFilesCmd = &cobra.Command{
+ Use: "files <backup-id>",
+ Short: "List files in a volume backup",
+ Args: cobra.ExactArgs(1),
+ SilenceUsage: true,
+ RunE: func(cmd *cobra.Command, args []string) error {
+ c, err := client.NewFromConfig()
+ if err != nil {
+ return err
+ }
+
+ resp, err := c.Get(cmd.Context(), types.VolumeBackupFiles(c.EnvID(), args[0]))
+ if err != nil {
+ return errors.WrapIf(err, "failed to list backup files")
+ }
+ defer func() { _ = resp.Body.Close() }()
+ if err := cmdutil.EnsureSuccessStatus(resp); err != nil {
+ return errors.WrapIf(err, "failed to list backup files")
+ }
+
+ var result base.ApiResponse[[]string]
+ if err := cmdutil.DecodeJSON(resp, &result); err != nil {
+ return err
+ }
+
+ if jsonOutput {
+ return cmdutil.PrintJSON(result.Data)
+ }
+
+ for _, file := range result.Data {
+ fmt.Println(file)
+ }
+ return nil
+ },
+}
+
+func init() {
+ VolumesCmd.AddCommand(renameCmd)
+ VolumesCmd.AddCommand(backupsCmd)
+
+ backupsCmd.AddCommand(backupsListCmd)
+ backupsCmd.AddCommand(backupsPolicyCmd)
+ backupsCmd.AddCommand(backupsCreateCmd)
+ backupsCmd.AddCommand(backupsRestoreCmd)
+ backupsCmd.AddCommand(backupsDeleteCmd)
+ backupsCmd.AddCommand(backupsUploadCmd)
+ backupsCmd.AddCommand(backupsDownloadCmd)
+ backupsCmd.AddCommand(backupsFilesCmd)
+
+ backupsPolicyCmd.AddCommand(backupsPolicyUpdateCmd)
+
+ renameCmd.Flags().BoolVarP(&forceFlag, "force", "f", false, "Rename without confirmation")
+ renameCmd.Flags().BoolVar(&jsonOutput, "json", false, "Output in JSON format")
+
+ backupsPolicyCmd.Flags().BoolVar(&jsonOutput, "json", false, "Output in JSON format")
+
+ backupsPolicyUpdateCmd.Flags().BoolVar(&policyEnabled, "enabled", false, "Enable or disable the policy")
+ backupsPolicyUpdateCmd.Flags().StringVar(&policySchedule, "schedule", "", "Backup schedule (cron expression)")
+ backupsPolicyUpdateCmd.Flags().IntVar(&policyRetention, "retention", 0, "Number of backups to retain")
+ backupsPolicyUpdateCmd.Flags().BoolVar(&policyStopContainers, "stop-containers", false, "Stop containers using the volume during backup")
+ backupsPolicyUpdateCmd.Flags().BoolVar(&policyLocal, "local", false, "Store backups locally")
+ backupsPolicyUpdateCmd.Flags().BoolVar(&policyS3, "s3", false, "Store backups in S3")
+ backupsPolicyUpdateCmd.Flags().StringVar(&policyS3Destination, "s3-destination", "", "Saved S3 destination ID")
+ backupsPolicyUpdateCmd.Flags().StringVar(&policyID, "policy-id", "", "Policy to update when the volume has multiple policies")
+ backupsPolicyUpdateCmd.Flags().StringVar(&policyFile, "file", "", "JSON file with the full policy collection to PUT")
+ backupsPolicyUpdateCmd.Flags().BoolVar(&jsonOutput, "json", false, "Output in JSON format")
+
+ for _, listLike := range []*cobra.Command{backupsCmd, backupsListCmd} {
+ listLike.Flags().IntVarP(&limitFlag, "limit", "n", 20, "Number of backups to show")
+ listLike.Flags().IntVar(&startFlag, "start", 0, cmdutil.StartFlagUsage)
+ listLike.Flags().BoolVarP(&allFlag, "all", "a", false, cmdutil.AllFlagUsage)
+ listLike.Flags().BoolVar(&jsonOutput, "json", false, "Output in JSON format")
+ }
+
+ backupsCreateCmd.Flags().StringVar(&backupCreateDestination, "destination", "", "Backup destination (local, s3, local_s3)")
+ backupsCreateCmd.Flags().StringVar(&backupCreateS3Destination, "s3-destination", "", "Saved S3 destination ID for a remote backup")
+ backupsCreateCmd.Flags().StringVar(&backupCreatePolicyID, "policy-id", "", "Backup policy whose settings should be used")
+ backupsCreateCmd.Flags().BoolVar(&jsonOutput, "json", false, "Output in JSON format")
+
+ backupsRestoreCmd.Flags().StringArrayVar(&restorePaths, "path", nil, "Restore only this path from the backup (repeatable)")
+ backupsRestoreCmd.Flags().StringVar(&restoreArchiveFile, "file", "", "Local tar.gz backup archive to upload and restore")
+ backupsRestoreCmd.Flags().BoolVarP(&forceFlag, "force", "f", false, "Restore without confirmation")
+ backupsRestoreCmd.Flags().BoolVar(&jsonOutput, "json", false, "Output in JSON format")
+
+ backupsDeleteCmd.Flags().BoolVarP(&forceFlag, "force", "f", false, "Delete without confirmation")
+
+ backupsUploadCmd.Flags().StringVar(&backupUploadS3Destination, "s3-destination", "", "S3 destination for the uploaded backup")
+ backupsUploadCmd.Flags().BoolVar(&jsonOutput, "json", false, "Output in JSON format")
+ _ = backupsUploadCmd.MarkFlagRequired("s3-destination")
+
+ backupsFilesCmd.Flags().BoolVar(&jsonOutput, "json", false, "Output in JSON format")
+}
diff --git a/cli/pkg/volumes/cmd.go b/cli/pkg/volumes/cmd.go
index 800525bb2..3b697625f 100644
--- a/cli/pkg/volumes/cmd.go
+++ b/cli/pkg/volumes/cmd.go
@@ -63,7 +63,7 @@ var listCmd = &cobra.Command{
return err
}
- path, err := cmdutil.ApplyPaginationParams(cmd, types.Endpoints.Volumes(c.EnvID()), cmdutil.ListParams{
+ path, err := cmdutil.ApplyPaginationParams(cmd, types.Volumes(c.EnvID()), cmdutil.ListParams{
Resource: "volumes",
Limit: limitFlag,
FallbackDefault: 20,
@@ -202,7 +202,7 @@ var deleteCmd = &cobra.Command{
}
deletePath := cmdutil.AppendQuery(
- types.Endpoints.Volume(c.EnvID(), resolved.Name),
+ types.Volume(c.EnvID(), resolved.Name),
url.Values{"force": []string{strconv.FormatBool(forceFlag)}},
)
resp, err := c.Delete(cmd.Context(), deletePath)
@@ -225,7 +225,7 @@ var countsCmd = &cobra.Command{
SilenceUsage: true,
RunE: func(cmd *cobra.Command, args []string) error {
return runVolumeDataCommand(cmd, volumeDataCommandConfig{
- endpoint: types.Endpoints.VolumesCounts,
+ endpoint: types.VolumesCounts,
failureMessage: "failed to get volume counts",
header: "Volume Usage Counts",
marshalMessage: "failed to marshal volume counts",
@@ -254,7 +254,7 @@ var pruneCmd = &cobra.Command{
return err
}
- resp, err := c.Post(cmd.Context(), types.Endpoints.VolumesPrune(c.EnvID()), nil)
+ resp, err := c.Post(cmd.Context(), types.VolumesPrune(c.EnvID()), nil)
if err != nil {
return errors.WrapIf(err, "failed to prune volumes")
}
@@ -288,7 +288,7 @@ var sizesCmd = &cobra.Command{
SilenceUsage: true,
RunE: func(cmd *cobra.Command, args []string) error {
return runVolumeDataCommand(cmd, volumeDataCommandConfig{
- endpoint: types.Endpoints.VolumesSizes,
+ endpoint: types.VolumesSizes,
failureMessage: "failed to get volume sizes",
header: "Volume Sizes",
marshalMessage: "failed to marshal volume sizes",
@@ -355,7 +355,7 @@ var usageCmd = &cobra.Command{
return err
}
- resp, err := c.Get(cmd.Context(), types.Endpoints.VolumeUsage(c.EnvID(), resolved.Name))
+ resp, err := c.Get(cmd.Context(), types.VolumeUsage(c.EnvID(), resolved.Name))
if err != nil {
return errors.WrapIf(err, "failed to get volume usage")
}
@@ -420,7 +420,7 @@ var createCmd = &cobra.Command{
}
}
- path := types.Endpoints.Volumes(c.EnvID())
+ path := types.Volumes(c.EnvID())
resp, err := c.Post(cmd.Context(), path, req)
if err != nil {
return errors.WrapIf(err, "failed to create volume")
@@ -502,7 +502,7 @@ func resolveVolume(ctx context.Context, c *client.Client, identifier string, all
return nil, errors.New("volume identifier is required")
}
- resp, err := c.Get(ctx, types.Endpoints.Volume(c.EnvID(), trimmed))
+ resp, err := c.Get(ctx, types.Volume(c.EnvID(), trimmed))
if err != nil {
return nil, errors.WrapIff(err, "failed to resolve volume %q", trimmed)
}
@@ -525,7 +525,7 @@ func resolveVolume(ctx context.Context, c *client.Client, identifier string, all
return nil, errors.Errorf("failed to resolve volume %q (status %d): %s", trimmed, resp.StatusCode, strings.TrimSpace(string(body)))
}
- searchPath := fmt.Sprintf("%s?search=%s&limit=%d", types.Endpoints.Volumes(c.EnvID()), url.QueryEscape(trimmed), cmdutil.ShowAllLimit)
+ searchPath := fmt.Sprintf("%s?search=%s&limit=%d", types.Volumes(c.EnvID()), url.QueryEscape(trimmed), cmdutil.ShowAllLimit)
searchResp, err := c.Get(ctx, searchPath)
if err != nil {
return nil, errors.WrapIf(err, "failed to search volumes")
diff --git a/cli/pkg/volumes/workspace.go b/cli/pkg/volumes/workspace.go
new file mode 100644
index 000000000..334b4d792
--- /dev/null
+++ b/cli/pkg/volumes/workspace.go
@@ -0,0 +1,326 @@
+package volumes
+
+import (
+ "bytes"
+ "encoding/json"
+ "fmt"
+ "mime/multipart"
+ "net/http"
+ "net/url"
+ "os"
+ "path"
+ "path/filepath"
+ "strings"
+ "time"
+
+ "emperror.dev/errors"
+
+ "github.com/getarcaneapp/arcane/cli/v2/internal/client"
+ "github.com/getarcaneapp/arcane/cli/v2/internal/cmdutil"
+ "github.com/getarcaneapp/arcane/cli/v2/internal/output"
+ "github.com/getarcaneapp/arcane/cli/v2/internal/prompt"
+ "github.com/getarcaneapp/arcane/cli/v2/internal/types"
+ "github.com/getarcaneapp/arcane/types/v2/base"
+ "github.com/getarcaneapp/arcane/types/v2/volume"
+ workspacetypes "github.com/getarcaneapp/arcane/types/v2/workspace"
+ "github.com/spf13/cobra"
+)
+
+var workspaceCmd = &cobra.Command{
+ Use: "workspace <volume-name> [path]",
+ Short: "Browse volume workspace files",
+ Args: cobra.RangeArgs(1, 2),
+ SilenceUsage: true,
+ RunE: func(cmd *cobra.Command, args []string) error {
+ c, err := client.NewFromConfig()
+ if err != nil {
+ return err
+ }
+
+ allowPrompt := !jsonOutput && prompt.IsInteractive()
+ resolved, err := resolveVolume(cmd.Context(), c, args[0], allowPrompt)
+ if err != nil {
+ return err
+ }
+
+ resp, err := c.Get(cmd.Context(), types.VolumeWorkspace(c.EnvID(), resolved.Name))
+ if err != nil {
+ return errors.WrapIf(err, "failed to get volume workspace")
+ }
+ defer func() { _ = resp.Body.Close() }()
+ if err := cmdutil.EnsureSuccessStatus(resp); err != nil {
+ return errors.WrapIf(err, "failed to get volume workspace")
+ }
+
+ var result base.ApiResponse[workspacetypes.Workspace]
+ if err := cmdutil.DecodeJSON(resp, &result); err != nil {
+ return err
+ }
+
+ // The endpoint returns the full tree; an optional path argument
+ // narrows the listing to that subtree.
+ entries := result.Data.Files
+ if len(args) == 2 {
+ prefix := strings.Trim(args[1], "/")
+ filtered := entries[:0:0]
+ for _, entry := range entries {
+ if entry.RelativePath == prefix || strings.HasPrefix(entry.RelativePath, prefix+"/") {
+ filtered = append(filtered, entry)
+ }
+ }
+ entries = filtered
+ }
+
+ if jsonOutput {
+ return cmdutil.PrintJSON(entries)
+ }
+
+ headers := []string{"PATH", "TYPE", "SIZE", "MODIFIED"}
+ rows := make([][]string, len(entries))
+ for i, entry := range entries {
+ entryType := "file"
+ switch {
+ case entry.IsDirectory:
+ entryType = "dir"
+ case entry.IsSymlink:
+ entryType = "symlink"
+ }
+ size := ""
+ if !entry.IsDirectory {
+ size = output.Bytes(entry.Size)
+ }
+ rows[i] = []string{
+ entry.RelativePath,
+ entryType,
+ size,
+ entry.ModTime.Format(time.RFC3339),
+ }
+ }
+ output.Table(headers, rows)
+ if result.Data.FileTreeTruncated {
+ output.Warning("File listing was truncated by the server")
+ }
+ return nil
+ },
+}
+
+var workspaceCatCmd = &cobra.Command{
+ Use: "cat <volume-name> <path>",
+ Short: "Print a volume workspace file",
+ Args: cobra.ExactArgs(2),
+ SilenceUsage: true,
+ RunE: func(cmd *cobra.Command, args []string) error {
+ c, err := client.NewFromConfig()
+ if err != nil {
+ return err
+ }
+
+ allowPrompt := !jsonOutput && prompt.IsInteractive()
+ resolved, err := resolveVolume(cmd.Context(), c, args[0], allowPrompt)
+ if err != nil {
+ return err
+ }
+
+ filePath := cmdutil.AppendQuery(
+ types.VolumeWorkspaceFile(c.EnvID(), resolved.Name),
+ url.Values{"relativePath": []string{args[1]}},
+ )
+ resp, err := c.Get(cmd.Context(), filePath)
+ if err != nil {
+ return errors.WrapIf(err, "failed to get workspace file")
+ }
+ defer func() { _ = resp.Body.Close() }()
+ if err := cmdutil.EnsureSuccessStatus(resp); err != nil {
+ return errors.WrapIf(err, "failed to get workspace file")
+ }
+
+ var result base.ApiResponse[workspacetypes.FileContent]
+ if err := cmdutil.DecodeJSON(resp, &result); err != nil {
+ return err
+ }
+
+ if jsonOutput {
+ return cmdutil.PrintJSON(result.Data)
+ }
+
+ if result.Data.Content == "" && result.Data.ReadOnlyReason != "" {
+ return errors.Errorf("file %s has no printable content (%s); use `arcane volumes workspace download` instead", args[1], result.Data.ReadOnlyReason)
+ }
+
+ fmt.Print(result.Data.Content)
+ return nil
+ },
+}
+
+var workspaceDownloadCmd = &cobra.Command{
+ Use: "download <volume-name> <path> [output-file]",
+ Short: "Download a volume workspace file",
+ Args: cobra.RangeArgs(2, 3),
+ SilenceUsage: true,
+ RunE: func(cmd *cobra.Command, args []string) error {
+ c, err := client.NewFromConfig()
+ if err != nil {
+ return err
+ }
+
+ allowPrompt := prompt.IsInteractive()
+ resolved, err := resolveVolume(cmd.Context(), c, args[0], allowPrompt)
+ if err != nil {
+ return err
+ }
+
+ // Downloading large files can take a long time
+ c.SetTimeout(30 * time.Minute)
+
+ downloadPath := cmdutil.AppendQuery(
+ types.VolumeWorkspaceFileDownload(c.EnvID(), resolved.Name),
+ url.Values{"relativePath": []string{args[1]}},
+ )
+ resp, err := c.Get(cmd.Context(), downloadPath)
+ if err != nil {
+ return errors.WrapIf(err, "failed to download workspace file")
+ }
+ defer func() { _ = resp.Body.Close() }()
+ if err := cmdutil.EnsureSuccessStatus(resp); err != nil {
+ return errors.WrapIf(err, "failed to download workspace file")
+ }
+
+ outputFile := ""
+ if len(args) == 3 {
+ outputFile = args[2]
+ }
+ if outputFile == "" {
+ outputFile = downloadFilename(resp, path.Base(args[1]))
+ }
+
+ if err := writeResponseToFile(resp.Body, outputFile); err != nil {
+ return err
+ }
+
+ output.Success("File downloaded to %s", outputFile)
+ return nil
+ },
+}
+
+var workspacePutCmd = &cobra.Command{
+ Use: "put <volume-name> <local-file> <path>",
+ Short: "Write a local file into a volume workspace",
+ Args: cobra.ExactArgs(3),
+ SilenceUsage: true,
+ RunE: func(cmd *cobra.Command, args []string) error {
+ c, err := client.NewFromConfig()
+ if err != nil {
+ return err
+ }
+
+ allowPrompt := !forceFlag && prompt.IsInteractive()
+ resolved, err := resolveVolume(cmd.Context(), c, args[0], allowPrompt)
+ if err != nil {
+ return err
+ }
+
+ content, err := os.ReadFile(args[1])
+ if err != nil {
+ return errors.WrapIf(err, "failed to read local file")
+ }
+
+ relativePath := strings.Trim(filepath.ToSlash(args[2]), "/")
+ if relativePath == "" {
+ return errors.New("destination path is required")
+ }
+
+ if !forceFlag {
+ confirmed, err := cmdutil.Confirm(cmd, fmt.Sprintf("Write %s to %s in volume %s?", args[1], relativePath, resolved.Name))
+ if err != nil {
+ return err
+ }
+ if !confirmed {
+ fmt.Println("Cancelled")
+ return nil
+ }
+ }
+
+ workspaceResp, err := c.Get(cmd.Context(), types.VolumeWorkspace(c.EnvID(), resolved.Name))
+ if err != nil {
+ return errors.WrapIf(err, "failed to get volume workspace")
+ }
+ defer func() { _ = workspaceResp.Body.Close() }()
+ if err := cmdutil.EnsureSuccessStatus(workspaceResp); err != nil {
+ return errors.WrapIf(err, "failed to get volume workspace")
+ }
+ var current base.ApiResponse[workspacetypes.Workspace]
+ if err := cmdutil.DecodeJSON(workspaceResp, &current); err != nil {
+ return err
+ }
+
+ operation := volume.FileOpCreateFile
+ for _, entry := range current.Data.Files {
+ if entry.RelativePath == relativePath && !entry.IsDirectory {
+ operation = volume.FileOpUpdateFile
+ break
+ }
+ }
+
+ uploadIndex := 0
+ manifest := volume.WorkspaceUpdateManifest{
+ FileTreeRevision: current.Data.FileTreeRevision,
+ FileChanges: []volume.WorkspaceFileChange{{
+ Operation: operation,
+ RelativePath: relativePath,
+ UploadIndex: &uploadIndex,
+ }},
+ }
+ manifestJSON, err := json.Marshal(manifest)
+ if err != nil {
+ return errors.WrapIf(err, "failed to encode workspace manifest")
+ }
+
+ var requestBody bytes.Buffer
+ writer := multipart.NewWriter(&requestBody)
+ if err := writer.WriteField("manifest", string(manifestJSON)); err != nil {
+ return errors.WrapIf(err, "failed to write workspace manifest")
+ }
+ filePart, err := writer.CreateFormFile("files", path.Base(relativePath))
+ if err != nil {
+ return errors.WrapIf(err, "failed to create workspace upload")
+ }
+ if _, err := filePart.Write(content); err != nil {
+ return errors.WrapIf(err, "failed to write workspace upload")
+ }
+ if err := writer.Close(); err != nil {
+ return errors.WrapIf(err, "failed to finalize workspace upload")
+ }
+
+ resp, err := c.RequestRaw(cmd.Context(), http.MethodPut, types.VolumeWorkspace(c.EnvID(), resolved.Name), &requestBody, map[string]string{"Content-Type": writer.FormDataContentType()})
+ if err != nil {
+ return errors.WrapIf(err, "failed to update volume workspace")
+ }
+ defer func() { _ = resp.Body.Close() }()
+ if err := cmdutil.EnsureSuccessStatus(resp); err != nil {
+ return errors.WrapIf(err, "failed to update volume workspace")
+ }
+
+ if jsonOutput {
+ var result base.ApiResponse[workspacetypes.Workspace]
+ if err := cmdutil.DecodeJSON(resp, &result); err != nil {
+ return err
+ }
+ return cmdutil.PrintJSON(result.Data)
+ }
+
+ output.Success("File %s written to volume %s", relativePath, resolved.Name)
+ return nil
+ },
+}
+
+func init() {
+ VolumesCmd.AddCommand(workspaceCmd)
+ workspaceCmd.AddCommand(workspaceCatCmd)
+ workspaceCmd.AddCommand(workspaceDownloadCmd)
+ workspaceCmd.AddCommand(workspacePutCmd)
+
+ workspaceCmd.Flags().BoolVar(&jsonOutput, "json", false, "Output in JSON format")
+ workspaceCatCmd.Flags().BoolVar(&jsonOutput, "json", false, "Output in JSON format")
+ workspacePutCmd.Flags().BoolVarP(&forceFlag, "force", "f", false, "Write without confirmation")
+ workspacePutCmd.Flags().BoolVar(&jsonOutput, "json", false, "Output in JSON format")
+}