Skip to content

Modern Docker Management, Designed for Everyone

feat: static admin api key support (#2088)

Kyle Mendell21d67c87ecef
diff --git a/.env.example b/.env.example
index a99ae7214..53022a6a1 100644
--- a/.env.example
+++ b/.env.example
@@ -27,6 +27,8 @@ PGID=1000
# IMPORTANT: Generate unique values for production!
ENCRYPTION_KEY=your-32-char-encryption-key-here
JWT_SECRET=your-super-secret-jwt-key-change-this
+# Optional: bootstrap a deterministic admin API key for IaC workflows (supports _FILE / __FILE variants)
+# ADMIN_STATIC_API_KEY=arc_your_deterministic_admin_api_key
# JWT refresh token expiry duration (default: 168h = 7 days). Accepts Go duration format (e.g., 72h, 720h, 8760h).
# JWT_REFRESH_EXPIRY=168h
diff --git a/backend/cli/generate/api_key_test.go b/backend/cli/generate/api_key_test.go
new file mode 100644
index 000000000..85473c890
--- /dev/null
+++ b/backend/cli/generate/api_key_test.go
@@ -0,0 +1,29 @@
+package generate
+
+import (
+ "strings"
+ "testing"
+)
+
+func TestAPIKeyCommandAvailableInBackendCLI(t *testing.T) {
+ cmd := GenerateCmd
+ cmd.SetArgs([]string{"api-key"})
+
+ out, err := captureOutput(func() error {
+ _, err := cmd.ExecuteC()
+ return err
+ })
+ if err != nil {
+ t.Fatalf("command failed: %v", err)
+ }
+
+ if strings.TrimSpace(out) == "" {
+ t.Fatalf("expected raw arc_ key in output, got: %q", out)
+ }
+ if !strings.HasPrefix(strings.TrimSpace(out), "arc_") {
+ t.Fatalf("expected raw arc_ key in output, got: %q", out)
+ }
+ if strings.Contains(out, "ADMIN_STATIC_API_KEY") {
+ t.Fatalf("expected raw arc_ key in output, got: %q", out)
+ }
+}
diff --git a/backend/cli/generate/generate.go b/backend/cli/generate/generate.go
index 55e36b104..95371b9c7 100644
--- a/backend/cli/generate/generate.go
+++ b/backend/cli/generate/generate.go
@@ -1,11 +1,8 @@
package generate
import (
+ cligenerate "github.com/getarcaneapp/arcane/cli/pkg/generate"
"github.com/spf13/cobra"
)
-var GenerateCmd = &cobra.Command{
- Use: "generate",
- Aliases: []string{"gen", "g"},
- Short: "Generate secrets for arcanes backend",
-}
+var GenerateCmd *cobra.Command = cligenerate.GenerateCmd
diff --git a/backend/cli/generate/secret.go b/backend/cli/generate/secret.go
deleted file mode 100644
index 4297ba39b..000000000
--- a/backend/cli/generate/secret.go
+++ /dev/null
@@ -1,113 +0,0 @@
-package generate
-
-import (
- crand "crypto/rand"
- "encoding/base64"
- "encoding/hex"
- "fmt"
-
- "github.com/spf13/cobra"
-)
-
-var (
- secretFormat string
- secretLength int
-)
-
-var secretCmd = &cobra.Command{
- Use: "secret",
- Short: "Generate cryptographic secrets",
- Long: `Generate secure cryptographic secrets for ENCRYPTION_KEY and JWT_SECRET.`,
- RunE: func(cmd *cobra.Command, args []string) error {
- return generateSecrets()
- },
-}
-
-func init() {
- GenerateCmd.AddCommand(secretCmd)
- secretCmd.Flags().StringVarP(&secretFormat, "format", "f", "base64", "output format: base64, hex, env, docker, all")
- secretCmd.Flags().IntVarP(&secretLength, "length", "l", 32, "secret length in bytes (default: 32 for AES-256)")
-}
-
-func generateSecrets() error {
- encryptionKey := make([]byte, secretLength)
- if _, err := crand.Read(encryptionKey); err != nil {
- return fmt.Errorf("failed to generate encryption key: %w", err)
- }
-
- jwtSecret := make([]byte, secretLength)
- if _, err := crand.Read(jwtSecret); err != nil {
- return fmt.Errorf("failed to generate JWT secret: %w", err)
- }
-
- switch secretFormat {
- case "base64":
- printBase64Format(encryptionKey, jwtSecret)
- case "hex":
- printHexFormat(encryptionKey, jwtSecret)
- case "env":
- printEnvFormat(encryptionKey, jwtSecret)
- case "docker":
- printDockerFormat(encryptionKey, jwtSecret)
- case "all":
- printAllFormats(encryptionKey, jwtSecret)
- default:
- return fmt.Errorf("unknown format: %s (supported: base64, hex, env, docker, all)", secretFormat)
- }
-
- return nil
-}
-
-func printBase64Format(encKey, jwtKey []byte) {
- fmt.Println("BASE64")
- fmt.Println("------")
- fmt.Printf("ENCRYPTION_KEY=%s\n", base64.StdEncoding.EncodeToString(encKey))
- fmt.Printf("JWT_SECRET=%s\n", base64.StdEncoding.EncodeToString(jwtKey))
-}
-
-func printHexFormat(encKey, jwtKey []byte) {
- fmt.Println("HEX")
- fmt.Println("---")
- fmt.Printf("ENCRYPTION_KEY=%s\n", hex.EncodeToString(encKey))
- fmt.Printf("JWT_SECRET=%s\n", hex.EncodeToString(jwtKey))
-}
-
-func printEnvFormat(encKey, jwtKey []byte) {
- fmt.Println("ENV (.env) FORMAT")
- fmt.Println("-------------------")
- fmt.Printf("ENCRYPTION_KEY=%s\n", base64.StdEncoding.EncodeToString(encKey))
- fmt.Printf("JWT_SECRET=%s\n", base64.StdEncoding.EncodeToString(jwtKey))
-}
-
-func printDockerFormat(encKey, jwtKey []byte) {
- fmt.Println("DOCKER COMPOSE ENVIRONMENT")
- fmt.Println("--------------------------")
- fmt.Println("environment:")
- fmt.Printf(" - ENCRYPTION_KEY=%s\n", base64.StdEncoding.EncodeToString(encKey))
- fmt.Printf(" - JWT_SECRET=%s\n", base64.StdEncoding.EncodeToString(jwtKey))
-}
-
-func printAllFormats(encKey, jwtKey []byte) {
- fmt.Println("Arcane cryptographic secrets")
- fmt.Println("===========================")
- fmt.Println()
-
- fmt.Println("ENV (.env) - recommended")
- fmt.Println("------------------------")
- fmt.Printf("ENCRYPTION_KEY=%s\n", base64.StdEncoding.EncodeToString(encKey))
- fmt.Printf("JWT_SECRET=%s\n", base64.StdEncoding.EncodeToString(jwtKey))
- fmt.Println()
-
- fmt.Println("Docker Compose (environment block)")
- fmt.Println("-------------------------------")
- fmt.Println("environment:")
- fmt.Printf(" - ENCRYPTION_KEY=%s\n", base64.StdEncoding.EncodeToString(encKey))
- fmt.Printf(" - JWT_SECRET=%s\n", base64.StdEncoding.EncodeToString(jwtKey))
- fmt.Println()
-
- fmt.Println("HEX")
- fmt.Println("---")
- fmt.Printf("ENCRYPTION_KEY=%s\n", hex.EncodeToString(encKey))
- fmt.Printf("JWT_SECRET=%s\n", hex.EncodeToString(jwtKey))
- fmt.Println()
-}
diff --git a/backend/go.mod b/backend/go.mod
index 13f721814..6e8765819 100644
--- a/backend/go.mod
+++ b/backend/go.mod
@@ -2,6 +2,7 @@ module github.com/getarcaneapp/arcane/backend
go 1.26.0
+replace github.com/getarcaneapp/arcane/cli => ../cli
replace github.com/getarcaneapp/arcane/types => ../types
require (
@@ -18,7 +19,8 @@ require (
github.com/docker/compose/v5 v5.1.0
github.com/docker/docker v28.5.2+incompatible
github.com/fsnotify/fsnotify v1.9.0
- github.com/getarcaneapp/arcane/types v1.15.3
+ github.com/getarcaneapp/arcane/cli v1.16.3
+ github.com/getarcaneapp/arcane/types v1.16.3
github.com/gin-contrib/cors v1.7.6
github.com/gin-gonic/gin v1.12.0
github.com/glebarez/sqlite v1.11.0
diff --git a/backend/internal/bootstrap/bootstrap.go b/backend/internal/bootstrap/bootstrap.go
index e4e2802ad..616386c6c 100644
--- a/backend/internal/bootstrap/bootstrap.go
+++ b/backend/internal/bootstrap/bootstrap.go
@@ -108,6 +108,7 @@ func initializeStartupState(appCtx context.Context, cfg *config.Config, appServi
Environment: string(cfg.Environment),
EncryptionKey: cfg.EncryptionKey,
AutoLoginUsername: cfg.AutoLoginUsername,
+ AdminStaticAPIKey: cfg.AdminStaticAPIKey,
}
startup.LoadAgentToken(appCtx, runtimeCfg, appServices.Settings.GetStringSetting)
@@ -174,6 +175,9 @@ func initializeStartupState(appCtx context.Context, cfg *config.Config, appServi
startup.InitializeNonAgentFeatures(appCtx, runtimeCfg,
appServices.User.CreateDefaultAdmin,
+ func(ctx context.Context) error {
+ return appServices.ApiKey.ReconcileDefaultAdminAPIKey(ctx, runtimeCfg.AdminStaticAPIKey)
+ },
func(ctx context.Context) error {
startup.InitializeAutoLogin(ctx, runtimeCfg)
return nil
diff --git a/backend/internal/config/config.go b/backend/internal/config/config.go
index 651e91c57..c5f63a8af 100644
--- a/backend/internal/config/config.go
+++ b/backend/internal/config/config.go
@@ -28,18 +28,19 @@ const (
// Fields with `options:"file"` support Docker secrets via the _FILE suffix.
// Available options: file, toLower, trimTrailingSlash
type Config struct {
- AppUrl string `env:"APP_URL" default:"http://localhost:3552"`
- DatabaseURL string `env:"DATABASE_URL" default:"file:data/arcane.db?_pragma=journal_mode(WAL)&_pragma=busy_timeout(2500)&_txlock=immediate" options:"file"`
- AllowDowngrade bool `env:"ALLOW_DOWNGRADE" default:"false"`
- Port string `env:"PORT" default:"3552"`
- Listen string `env:"LISTEN" default:""`
- TLSEnabled bool `env:"TLS_ENABLED" default:"false"`
- TLSCertFile string `env:"TLS_CERT_FILE" default:""`
- TLSKeyFile string `env:"TLS_KEY_FILE" default:""`
- Environment AppEnvironment `env:"ENVIRONMENT" default:"production"`
- JWTSecret string `env:"JWT_SECRET" default:"default-jwt-secret-change-me" options:"file"` //nolint:gosec // configuration field name is part of stable config API
- JWTRefreshExpiry time.Duration `env:"JWT_REFRESH_EXPIRY" default:"168h"`
- EncryptionKey string `env:"ENCRYPTION_KEY" default:"arcane-dev-key-32-characters!!!" options:"file"`
+ AppUrl string `env:"APP_URL" default:"http://localhost:3552"`
+ DatabaseURL string `env:"DATABASE_URL" default:"file:data/arcane.db?_pragma=journal_mode(WAL)&_pragma=busy_timeout(2500)&_txlock=immediate" options:"file"`
+ AllowDowngrade bool `env:"ALLOW_DOWNGRADE" default:"false"`
+ Port string `env:"PORT" default:"3552"`
+ Listen string `env:"LISTEN" default:""`
+ TLSEnabled bool `env:"TLS_ENABLED" default:"false"`
+ TLSCertFile string `env:"TLS_CERT_FILE" default:""`
+ TLSKeyFile string `env:"TLS_KEY_FILE" default:""`
+ Environment AppEnvironment `env:"ENVIRONMENT" default:"production"`
+ JWTSecret string `env:"JWT_SECRET" default:"default-jwt-secret-change-me" options:"file"` //nolint:gosec // configuration field name is part of stable config API
+ JWTRefreshExpiry time.Duration `env:"JWT_REFRESH_EXPIRY" default:"168h"`
+ EncryptionKey string `env:"ENCRYPTION_KEY" default:"arcane-dev-key-32-characters!!!" options:"file"`
+ AdminStaticAPIKey string `env:"ADMIN_STATIC_API_KEY" default:"" options:"file"`
OidcEnabled bool `env:"OIDC_ENABLED" default:"false"`
OidcClientID string `env:"OIDC_CLIENT_ID" default:"" options:"file"`
diff --git a/backend/internal/config/config_test.go b/backend/internal/config/config_test.go
index 557dde888..f55150a54 100644
--- a/backend/internal/config/config_test.go
+++ b/backend/internal/config/config_test.go
@@ -68,6 +68,9 @@ func TestConfig_DockerSecretsFileSupport(t *testing.T) {
origJWTSecret := os.Getenv("JWT_SECRET")
origJWTSecretFile := os.Getenv("JWT_SECRET_FILE")
origJWTSecretDoubleFile := os.Getenv("JWT_SECRET__FILE")
+ origDefaultAPIKey := os.Getenv("ADMIN_STATIC_API_KEY")
+ origDefaultAPIKeyFile := os.Getenv("ADMIN_STATIC_API_KEY_FILE")
+ origDefaultAPIKeyDoubleFile := os.Getenv("ADMIN_STATIC_API_KEY__FILE")
defer func() {
restoreEnv("ENCRYPTION_KEY", origEncryptionKey)
@@ -76,6 +79,9 @@ func TestConfig_DockerSecretsFileSupport(t *testing.T) {
restoreEnv("JWT_SECRET", origJWTSecret)
restoreEnv("JWT_SECRET_FILE", origJWTSecretFile)
restoreEnv("JWT_SECRET__FILE", origJWTSecretDoubleFile)
+ restoreEnv("ADMIN_STATIC_API_KEY", origDefaultAPIKey)
+ restoreEnv("ADMIN_STATIC_API_KEY_FILE", origDefaultAPIKeyFile)
+ restoreEnv("ADMIN_STATIC_API_KEY__FILE", origDefaultAPIKeyDoubleFile)
}()
t.Run("Load sensitive field from _FILE env var", func(t *testing.T) {
@@ -131,6 +137,16 @@ func TestConfig_DockerSecretsFileSupport(t *testing.T) {
assert.Equal(t, directValue, cfg.EncryptionKey)
})
+ t.Run("Default admin API key supports direct env var", func(t *testing.T) {
+ directValue := "arc_directbootstrapkey1234567890"
+ setEnv(t, "ADMIN_STATIC_API_KEY", directValue)
+ unsetEnv(t, "ADMIN_STATIC_API_KEY_FILE")
+ unsetEnv(t, "ADMIN_STATIC_API_KEY__FILE")
+
+ cfg := Load()
+ assert.Equal(t, directValue, cfg.AdminStaticAPIKey)
+ })
+
t.Run("_FILE takes precedence over direct env var", func(t *testing.T) {
// Create a temp file with the secret
tmpDir := t.TempDir()
@@ -148,6 +164,21 @@ func TestConfig_DockerSecretsFileSupport(t *testing.T) {
assert.Equal(t, fileValue, cfg.EncryptionKey)
})
+ t.Run("Default admin API key loads from _FILE env var", func(t *testing.T) {
+ tmpDir := t.TempDir()
+ secretFile := filepath.Join(tmpDir, "default_api_key")
+ secretValue := "arc_filebootstrapkey1234567890"
+ err := os.WriteFile(secretFile, []byte(secretValue), 0o600)
+ require.NoError(t, err)
+
+ unsetEnv(t, "ADMIN_STATIC_API_KEY")
+ unsetEnv(t, "ADMIN_STATIC_API_KEY__FILE")
+ setEnv(t, "ADMIN_STATIC_API_KEY_FILE", secretFile)
+
+ cfg := Load()
+ assert.Equal(t, secretValue, cfg.AdminStaticAPIKey)
+ })
+
t.Run("__FILE takes precedence over _FILE", func(t *testing.T) {
tmpDir := t.TempDir()
@@ -169,6 +200,25 @@ func TestConfig_DockerSecretsFileSupport(t *testing.T) {
assert.Equal(t, "double-underscore-value-32chars!!", cfg.JWTSecret)
})
+ t.Run("Default admin API key __FILE takes precedence over _FILE", func(t *testing.T) {
+ tmpDir := t.TempDir()
+
+ singleFile := filepath.Join(tmpDir, "default_api_key_single")
+ err := os.WriteFile(singleFile, []byte("arc_singlebootstrapkey1234567890"), 0o600)
+ require.NoError(t, err)
+
+ doubleFile := filepath.Join(tmpDir, "default_api_key_double")
+ err = os.WriteFile(doubleFile, []byte("arc_doublebootstrapkey1234567890\n"), 0o600)
+ require.NoError(t, err)
+
+ unsetEnv(t, "ADMIN_STATIC_API_KEY")
+ setEnv(t, "ADMIN_STATIC_API_KEY_FILE", singleFile)
+ setEnv(t, "ADMIN_STATIC_API_KEY__FILE", doubleFile)
+
+ cfg := Load()
+ assert.Equal(t, "arc_doublebootstrapkey1234567890", cfg.AdminStaticAPIKey)
+ })
+
t.Run("Non-sensitive fields do not support _FILE suffix", func(t *testing.T) {
// Create a temp file
tmpDir := t.TempDir()
diff --git a/backend/internal/huma/handlers/apikeys.go b/backend/internal/huma/handlers/apikeys.go
index 06fac4542..a4c8d2372 100644
--- a/backend/internal/huma/handlers/apikeys.go
+++ b/backend/internal/huma/handlers/apikeys.go
@@ -259,6 +259,9 @@ func (h *ApiKeyHandler) UpdateApiKey(ctx context.Context, input *UpdateApiKeyInp
if errors.Is(err, services.ErrApiKeyNotFound) {
return nil, huma.Error404NotFound((&common.ApiKeyNotFoundError{}).Error())
}
+ if errors.Is(err, services.ErrApiKeyProtected) {
+ return nil, huma.Error403Forbidden("static API keys cannot be updated")
+ }
return nil, huma.Error500InternalServerError((&common.ApiKeyUpdateError{Err: err}).Error())
}
@@ -285,6 +288,9 @@ func (h *ApiKeyHandler) DeleteApiKey(ctx context.Context, input *DeleteApiKeyInp
if errors.Is(err, services.ErrApiKeyNotFound) {
return nil, huma.Error404NotFound((&common.ApiKeyNotFoundError{}).Error())
}
+ if errors.Is(err, services.ErrApiKeyProtected) {
+ return nil, huma.Error403Forbidden("static API keys cannot be deleted")
+ }
return nil, huma.Error500InternalServerError((&common.ApiKeyDeletionError{Err: err}).Error())
}
diff --git a/backend/internal/models/api_key.go b/backend/internal/models/api_key.go
index d37bce2d6..2f62629f2 100644
--- a/backend/internal/models/api_key.go
+++ b/backend/internal/models/api_key.go
@@ -9,6 +9,7 @@ type ApiKey struct {
Description *string `json:"description,omitempty" gorm:"column:description"`
KeyHash string `json:"-" gorm:"column:key_hash;not null"`
KeyPrefix string `json:"keyPrefix" gorm:"column:key_prefix;not null"`
+ ManagedBy *string `json:"-" gorm:"column:managed_by"`
UserID string `json:"userId" gorm:"column:user_id;not null"`
EnvironmentID *string `json:"environmentId,omitempty" gorm:"column:environment_id"`
ExpiresAt *time.Time `json:"expiresAt,omitempty" gorm:"column:expires_at" sortable:"true"`
diff --git a/backend/internal/services/api_key_service.go b/backend/internal/services/api_key_service.go
index b85c98731..e7fee5f10 100644
--- a/backend/internal/services/api_key_service.go
+++ b/backend/internal/services/api_key_service.go
@@ -6,6 +6,7 @@ import (
"encoding/hex"
"errors"
"fmt"
+ "log/slog"
"strings"
"time"
@@ -17,9 +18,10 @@ import (
)
var (
- ErrApiKeyNotFound = errors.New("API key not found")
- ErrApiKeyExpired = errors.New("API key has expired")
- ErrApiKeyInvalid = errors.New("invalid API key")
+ ErrApiKeyNotFound = errors.New("API key not found")
+ ErrApiKeyExpired = errors.New("API key has expired")
+ ErrApiKeyInvalid = errors.New("invalid API key")
+ ErrApiKeyProtected = errors.New("API key is protected")
)
const (
@@ -27,8 +29,17 @@ const (
apiKeyLength = 32
apiKeyPrefixLen = 8
apiKeyLastUsedWriteWindow = 5 * time.Minute
+
+ managedByAdminBootstrap = "admin_account_default_api_key"
+ defaultAdminUsername = "arcane"
+ defaultAdminAPIKeyName = "Static Admin API Key"
)
+var defaultAdminAPIKeyDescription = func() *string {
+ description := "Environment-managed static API key for the built-in admin account"
+ return &description
+}()
+
type ApiKeyService struct {
db *database.DB
userService *UserService
@@ -59,6 +70,24 @@ func (s *ApiKeyService) validateApiKeyHash(hash, key string) error {
return s.userService.ValidatePassword(hash, key)
}
+func normalizeAPIKeyInputInternal(rawKey string) string {
+ return strings.TrimSpace(rawKey)
+}
+
+func parseAPIKeyPrefixInternal(rawKey string) (string, error) {
+ rawKey = normalizeAPIKeyInputInternal(rawKey)
+ if !strings.HasPrefix(rawKey, apiKeyPrefix) {
+ return "", ErrApiKeyInvalid
+ }
+
+ prefixLen := len(apiKeyPrefix) + apiKeyPrefixLen
+ if len(rawKey) < prefixLen {
+ return "", ErrApiKeyInvalid
+ }
+
+ return rawKey[:prefixLen], nil
+}
+
func (s *ApiKeyService) markApiKeyUsedAsync(ctx context.Context, keyID string) {
go func(keyID string) {
bgCtx := context.WithoutCancel(ctx)
@@ -77,20 +106,37 @@ func (s *ApiKeyService) CreateApiKey(ctx context.Context, userID string, req api
return nil, err
}
+ return s.createAPIKeyWithRawKey(ctx, userID, rawKey, req, nil, nil)
+}
+
+func (s *ApiKeyService) createAPIKeyWithRawKey(
+ ctx context.Context,
+ userID string,
+ rawKey string,
+ req apikey.CreateApiKey,
+ managedBy *string,
+ environmentID *string,
+) (*apikey.ApiKeyCreatedDto, error) {
+ rawKey = normalizeAPIKeyInputInternal(rawKey)
+ keyPrefix, err := parseAPIKeyPrefixInternal(rawKey)
+ if err != nil {
+ return nil, err
+ }
+
keyHash, err := s.hashApiKey(rawKey)
if err != nil {
return nil, fmt.Errorf("failed to hash API key: %w", err)
}
- keyPrefix := rawKey[:len(apiKeyPrefix)+apiKeyPrefixLen]
-
ak := &models.ApiKey{
- Name: req.Name,
- Description: req.Description,
- KeyHash: keyHash,
- KeyPrefix: keyPrefix,
- UserID: userID,
- ExpiresAt: req.ExpiresAt,
+ Name: req.Name,
+ Description: req.Description,
+ KeyHash: keyHash,
+ KeyPrefix: keyPrefix,
+ ManagedBy: managedBy,
+ UserID: userID,
+ EnvironmentID: environmentID,
+ ExpiresAt: req.ExpiresAt,
}
if err := s.db.WithContext(ctx).Create(ak).Error; err != nil {
@@ -98,33 +144,175 @@ func (s *ApiKeyService) CreateApiKey(ctx context.Context, userID string, req api
}
return &apikey.ApiKeyCreatedDto{
- ApiKey: apikey.ApiKey{
- ID: ak.ID,
- Name: ak.Name,
- Description: ak.Description,
- KeyPrefix: ak.KeyPrefix,
- UserID: ak.UserID,
- ExpiresAt: ak.ExpiresAt,
- LastUsedAt: ak.LastUsedAt,
- CreatedAt: ak.CreatedAt,
- UpdatedAt: ak.UpdatedAt,
- },
- Key: rawKey,
+ ApiKey: toAPIKeyDTOInternal(ak),
+ Key: rawKey,
}, nil
}
-func (s *ApiKeyService) CreateEnvironmentApiKey(ctx context.Context, environmentID string, userID string) (*apikey.ApiKeyCreatedDto, error) {
- rawKey, err := s.generateApiKey()
+func isStaticAPIKeyInternal(ak models.ApiKey) bool {
+ return ak.ManagedBy != nil && *ak.ManagedBy == managedByAdminBootstrap
+}
+
+func toAPIKeyDTOInternal(ak *models.ApiKey) apikey.ApiKey {
+ return apikey.ApiKey{
+ ID: ak.ID,
+ Name: ak.Name,
+ Description: ak.Description,
+ KeyPrefix: ak.KeyPrefix,
+ UserID: ak.UserID,
+ IsStatic: isStaticAPIKeyInternal(*ak),
+ ExpiresAt: ak.ExpiresAt,
+ LastUsedAt: ak.LastUsedAt,
+ CreatedAt: ak.CreatedAt,
+ UpdatedAt: ak.UpdatedAt,
+ }
+}
+
+func (s *ApiKeyService) CreateDefaultAdminAPIKey(ctx context.Context, userID, rawKey string) (*apikey.ApiKeyCreatedDto, error) {
+ managedBy := managedByAdminBootstrap
+ return s.createAPIKeyWithRawKey(ctx, userID, rawKey, apikey.CreateApiKey{
+ Name: defaultAdminAPIKeyName,
+ Description: defaultAdminAPIKeyDescription,
+ }, &managedBy, nil)
+}
+
+func (s *ApiKeyService) getDefaultAdminUser(ctx context.Context) (*models.User, error) {
+ adminUser, err := s.userService.GetUserByUsername(ctx, defaultAdminUsername)
if err != nil {
- return nil, err
+ if errors.Is(err, ErrUserNotFound) {
+ slog.WarnContext(ctx, "Default admin user not found, skipping default admin API key reconciliation", "username", defaultAdminUsername)
+ return nil, nil
+ }
+ return nil, fmt.Errorf("failed to load default admin user: %w", err)
+ }
+
+ return adminUser, nil
+}
+
+func (s *ApiKeyService) listManagedAPIKeys(tx *gorm.DB, userID string) ([]models.ApiKey, error) {
+ var managedKeys []models.ApiKey
+ if err := tx.Where("user_id = ? AND managed_by = ?", userID, managedByAdminBootstrap).
+ Order("created_at asc, id asc").
+ Find(&managedKeys).Error; err != nil {
+ return nil, fmt.Errorf("failed to load managed API keys: %w", err)
+ }
+
+ return managedKeys, nil
+}
+
+func (s *ApiKeyService) deleteManagedAPIKeysByIDs(tx *gorm.DB, ids []string) error {
+ if len(ids) == 0 {
+ return nil
+ }
+ if err := tx.Delete(&models.ApiKey{}, "id IN ?", ids).Error; err != nil {
+ return fmt.Errorf("failed to delete managed API keys: %w", err)
+ }
+ return nil
+}
+
+func (s *ApiKeyService) findMatchingManagedAPIKey(rawKey string, managedKeys []models.ApiKey) int {
+ for i, managedKey := range managedKeys {
+ if err := s.validateApiKeyHash(managedKey.KeyHash, rawKey); err == nil {
+ return i
+ }
+ }
+ return -1
+}
+
+func managedAPIKeyDeleteIDsInternal(managedKeys []models.ApiKey, keepIndex int) []string {
+ deleteIDs := make([]string, 0, len(managedKeys))
+ for i, managedKey := range managedKeys {
+ if i == keepIndex {
+ continue
+ }
+ deleteIDs = append(deleteIDs, managedKey.ID)
+ }
+ return deleteIDs
+}
+
+func (s *ApiKeyService) updateMatchingManagedAPIKey(tx *gorm.DB, apiKeyID string) error {
+ if err := tx.Model(&models.ApiKey{}).
+ Where("id = ?", apiKeyID).
+ Updates(map[string]any{
+ "name": defaultAdminAPIKeyName,
+ "description": defaultAdminAPIKeyDescription,
+ "managed_by": managedByAdminBootstrap,
+ }).Error; err != nil {
+ return fmt.Errorf("failed to update managed API key metadata: %w", err)
+ }
+ return nil
+}
+
+func (s *ApiKeyService) createManagedDefaultAdminAPIKey(tx *gorm.DB, userID, rawKey string) error {
+ keyPrefix, err := parseAPIKeyPrefixInternal(rawKey)
+ if err != nil {
+ return err
}
keyHash, err := s.hashApiKey(rawKey)
if err != nil {
- return nil, fmt.Errorf("failed to hash API key: %w", err)
+ return fmt.Errorf("failed to hash API key: %w", err)
+ }
+
+ managedBy := managedByAdminBootstrap
+ ak := &models.ApiKey{
+ Name: defaultAdminAPIKeyName,
+ Description: defaultAdminAPIKeyDescription,
+ KeyHash: keyHash,
+ KeyPrefix: keyPrefix,
+ ManagedBy: &managedBy,
+ UserID: userID,
+ }
+
+ if err := tx.Create(ak).Error; err != nil {
+ return fmt.Errorf("failed to create managed API key: %w", err)
+ }
+ return nil
+}
+
+func (s *ApiKeyService) reconcileManagedAPIKeys(tx *gorm.DB, userID string, rawKey string) error {
+ managedKeys, err := s.listManagedAPIKeys(tx, userID)
+ if err != nil {
+ return err
+ }
+
+ if rawKey == "" {
+ return s.deleteManagedAPIKeysByIDs(tx, managedAPIKeyDeleteIDsInternal(managedKeys, -1))
+ }
+
+ matchingIndex := s.findMatchingManagedAPIKey(rawKey, managedKeys)
+ if matchingIndex >= 0 {
+ if err := s.updateMatchingManagedAPIKey(tx, managedKeys[matchingIndex].ID); err != nil {
+ return err
+ }
+ return s.deleteManagedAPIKeysByIDs(tx, managedAPIKeyDeleteIDsInternal(managedKeys, matchingIndex))
}
- keyPrefix := rawKey[:len(apiKeyPrefix)+apiKeyPrefixLen]
+ if err := s.deleteManagedAPIKeysByIDs(tx, managedAPIKeyDeleteIDsInternal(managedKeys, -1)); err != nil {
+ return err
+ }
+
+ return s.createManagedDefaultAdminAPIKey(tx, userID, rawKey)
+}
+
+func (s *ApiKeyService) ReconcileDefaultAdminAPIKey(ctx context.Context, rawKey string) error {
+ rawKey = normalizeAPIKeyInputInternal(rawKey)
+
+ adminUser, err := s.getDefaultAdminUser(ctx)
+ if err != nil || adminUser == nil {
+ return err
+ }
+
+ return s.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
+ return s.reconcileManagedAPIKeys(tx, adminUser.ID, rawKey)
+ })
+}
+
+func (s *ApiKeyService) CreateEnvironmentApiKey(ctx context.Context, environmentID string, userID string) (*apikey.ApiKeyCreatedDto, error) {
+ rawKey, err := s.generateApiKey()
+ if err != nil {
+ return nil, err
+ }
envIDShort := environmentID
if len(environmentID) > 8 {
@@ -133,33 +321,10 @@ func (s *ApiKeyService) CreateEnvironmentApiKey(ctx context.Context, environment
name := fmt.Sprintf("Environment Bootstrap Key - %s", envIDShort)
description := "Auto-generated key for environment pairing"
- ak := &models.ApiKey{
- Name: name,
- Description: new(description),
- KeyHash: keyHash,
- KeyPrefix: keyPrefix,
- UserID: userID,
- EnvironmentID: new(environmentID),
- }
-
- if err := s.db.WithContext(ctx).Create(ak).Error; err != nil {
- return nil, fmt.Errorf("failed to create environment API key: %w", err)
- }
-
- return &apikey.ApiKeyCreatedDto{
- ApiKey: apikey.ApiKey{
- ID: ak.ID,
- Name: ak.Name,
- Description: ak.Description,
- KeyPrefix: ak.KeyPrefix,
- UserID: ak.UserID,
- ExpiresAt: ak.ExpiresAt,
- LastUsedAt: ak.LastUsedAt,
- CreatedAt: ak.CreatedAt,
- UpdatedAt: ak.UpdatedAt,
- },
- Key: rawKey,
- }, nil
+ return s.createAPIKeyWithRawKey(ctx, userID, rawKey, apikey.CreateApiKey{
+ Name: name,
+ Description: &description,
+ }, nil, &environmentID)
}
func (s *ApiKeyService) GetApiKey(ctx context.Context, id string) (*apikey.ApiKey, error) {
@@ -177,6 +342,7 @@ func (s *ApiKeyService) GetApiKey(ctx context.Context, id string) (*apikey.ApiKe
Description: ak.Description,
KeyPrefix: ak.KeyPrefix,
UserID: ak.UserID,
+ IsStatic: isStaticAPIKeyInternal(ak),
ExpiresAt: ak.ExpiresAt,
LastUsedAt: ak.LastUsedAt,
CreatedAt: ak.CreatedAt,
@@ -203,17 +369,7 @@ func (s *ApiKeyService) ListApiKeys(ctx context.Context, params pagination.Query
result := make([]apikey.ApiKey, len(apiKeys))
for i, ak := range apiKeys {
- result[i] = apikey.ApiKey{
- ID: ak.ID,
- Name: ak.Name,
- Description: ak.Description,
- KeyPrefix: ak.KeyPrefix,
- UserID: ak.UserID,
- ExpiresAt: ak.ExpiresAt,
- LastUsedAt: ak.LastUsedAt,
- CreatedAt: ak.CreatedAt,
- UpdatedAt: ak.UpdatedAt,
- }
+ result[i] = toAPIKeyDTOInternal(&ak)
}
return result, paginationResp, nil
@@ -227,6 +383,9 @@ func (s *ApiKeyService) UpdateApiKey(ctx context.Context, id string, req apikey.
}
return nil, fmt.Errorf("failed to get API key: %w", err)
}
+ if isStaticAPIKeyInternal(ak) {
+ return nil, ErrApiKeyProtected
+ }
if req.Name != nil {
ak.Name = *req.Name
@@ -248,6 +407,7 @@ func (s *ApiKeyService) UpdateApiKey(ctx context.Context, id string, req apikey.
Description: ak.Description,
KeyPrefix: ak.KeyPrefix,
UserID: ak.UserID,
+ IsStatic: isStaticAPIKeyInternal(ak),
ExpiresAt: ak.ExpiresAt,
LastUsedAt: ak.LastUsedAt,
CreatedAt: ak.CreatedAt,
@@ -256,6 +416,17 @@ func (s *ApiKeyService) UpdateApiKey(ctx context.Context, id string, req apikey.
}
func (s *ApiKeyService) DeleteApiKey(ctx context.Context, id string) error {
+ var apiKey models.ApiKey
+ if err := s.db.WithContext(ctx).Where("id = ?", id).First(&apiKey).Error; err != nil {
+ if errors.Is(err, gorm.ErrRecordNotFound) {
+ return ErrApiKeyNotFound
+ }
+ return fmt.Errorf("failed to load API key: %w", err)
+ }
+ if isStaticAPIKeyInternal(apiKey) {
+ return ErrApiKeyProtected
+ }
+
result := s.db.WithContext(ctx).Delete(&models.ApiKey{}, "id = ?", id)
if result.Error != nil {
return fmt.Errorf("failed to delete API key: %w", result.Error)
@@ -267,17 +438,17 @@ func (s *ApiKeyService) DeleteApiKey(ctx context.Context, id string) error {
}
func (s *ApiKeyService) ValidateApiKey(ctx context.Context, rawKey string) (*models.User, error) {
- if !strings.HasPrefix(rawKey, apiKeyPrefix) {
- return nil, ErrApiKeyInvalid
+ keyPrefix, err := parseAPIKeyPrefixInternal(rawKey)
+ if err != nil {
+ return nil, err
}
- keyPrefix := rawKey[:len(apiKeyPrefix)+apiKeyPrefixLen]
-
var apiKeys []models.ApiKey
if err := s.db.WithContext(ctx).Where("key_prefix = ?", keyPrefix).Find(&apiKeys).Error; err != nil {
return nil, fmt.Errorf("failed to find API keys: %w", err)
}
+ rawKey = normalizeAPIKeyInputInternal(rawKey)
for _, apiKey := range apiKeys {
if err := s.validateApiKeyHash(apiKey.KeyHash, rawKey); err == nil {
if apiKey.ExpiresAt != nil && apiKey.ExpiresAt.Before(time.Now()) {
@@ -299,17 +470,17 @@ func (s *ApiKeyService) ValidateApiKey(ctx context.Context, rawKey string) (*mod
}
func (s *ApiKeyService) GetEnvironmentByApiKey(ctx context.Context, rawKey string) (*string, error) {
- if !strings.HasPrefix(rawKey, apiKeyPrefix) {
- return nil, ErrApiKeyInvalid
+ keyPrefix, err := parseAPIKeyPrefixInternal(rawKey)
+ if err != nil {
+ return nil, err
}
- keyPrefix := rawKey[:len(apiKeyPrefix)+apiKeyPrefixLen]
-
var apiKeys []models.ApiKey
if err := s.db.WithContext(ctx).Where("key_prefix = ?", keyPrefix).Find(&apiKeys).Error; err != nil {
return nil, fmt.Errorf("failed to find API keys: %w", err)
}
+ rawKey = normalizeAPIKeyInputInternal(rawKey)
for _, apiKey := range apiKeys {
if err := s.validateApiKeyHash(apiKey.KeyHash, rawKey); err == nil {
if apiKey.ExpiresAt != nil && apiKey.ExpiresAt.Before(time.Now()) {
diff --git a/backend/internal/services/api_key_service_test.go b/backend/internal/services/api_key_service_test.go
index a1bf6721f..57c4f0e01 100644
--- a/backend/internal/services/api_key_service_test.go
+++ b/backend/internal/services/api_key_service_test.go
@@ -64,6 +64,15 @@ func fetchAPIKey(t *testing.T, db *database.DB, keyID string) models.ApiKey {
return apiKey
}
+func listAPIKeysForUser(t *testing.T, db *database.DB, userID string) []models.ApiKey {
+ t.Helper()
+
+ var apiKeys []models.ApiKey
+ err := db.WithContext(context.Background()).Where("user_id = ?", userID).Order("created_at asc").Find(&apiKeys).Error
+ require.NoError(t, err)
+ return apiKeys
+}
+
func requireAPIKeyLastUsedEventually(t *testing.T, db *database.DB, keyID string) models.ApiKey {
t.Helper()
@@ -103,6 +112,224 @@ func invalidateAPIKey(rawKey string) string {
return rawKey[:len(rawKey)-1] + "0"
}
+func createDefaultAdminUser(t *testing.T, ctx context.Context, userService *UserService) *models.User {
+ t.Helper()
+
+ user := &models.User{
+ BaseModel: models.BaseModel{ID: "default-admin-user"},
+ Username: defaultAdminUsername,
+ Roles: models.StringSlice{"admin"},
+ }
+
+ created, err := userService.CreateUser(ctx, user)
+ require.NoError(t, err)
+ return created
+}
+
+func TestCreateDefaultAdminAPIKeyUsesProvidedRawKey(t *testing.T) {
+ ctx := context.Background()
+ service, db, userService := setupAPIKeyService(t)
+ user := createTestAPIKeyUser(t, ctx, userService, "user-default-admin")
+
+ rawKey := "arc_bootstrapprovidedkey1234567890"
+ created, err := service.CreateDefaultAdminAPIKey(ctx, user.ID, rawKey)
+ require.NoError(t, err)
+ require.Equal(t, rawKey, created.Key)
+ require.Equal(t, defaultAdminAPIKeyName, created.ApiKey.Name)
+ require.True(t, created.ApiKey.IsStatic)
+
+ stored := fetchAPIKey(t, db, created.ApiKey.ID)
+ require.NotEqual(t, rawKey, stored.KeyHash)
+ require.Equal(t, rawKey[:len(apiKeyPrefix)+apiKeyPrefixLen], stored.KeyPrefix)
+ require.NotNil(t, stored.ManagedBy)
+ require.Equal(t, managedByAdminBootstrap, *stored.ManagedBy)
+}
+
+func TestReconcileDefaultAdminAPIKeyCreatesManagedKey(t *testing.T) {
+ ctx := context.Background()
+ service, db, userService := setupAPIKeyService(t)
+ adminUser := createDefaultAdminUser(t, ctx, userService)
+
+ rawKey := "arc_bootstrapcreate1234567890"
+ err := service.ReconcileDefaultAdminAPIKey(ctx, rawKey)
+ require.NoError(t, err)
+
+ apiKeys := listAPIKeysForUser(t, db, adminUser.ID)
+ require.Len(t, apiKeys, 1)
+ require.Equal(t, defaultAdminAPIKeyName, apiKeys[0].Name)
+ require.NotNil(t, apiKeys[0].Description)
+ require.Equal(t, *defaultAdminAPIKeyDescription, *apiKeys[0].Description)
+ require.NotNil(t, apiKeys[0].ManagedBy)
+ require.Equal(t, managedByAdminBootstrap, *apiKeys[0].ManagedBy)
+
+ validatedUser, err := service.ValidateApiKey(ctx, rawKey)
+ require.NoError(t, err)
+ require.Equal(t, adminUser.ID, validatedUser.ID)
+}
+
+func TestDeleteApiKeyRejectsStaticKey(t *testing.T) {
+ ctx := context.Background()
+ service, db, userService := setupAPIKeyService(t)
+ adminUser := createDefaultAdminUser(t, ctx, userService)
+
+ created, err := service.CreateDefaultAdminAPIKey(ctx, adminUser.ID, "arc_bootstrapprotected1234567890")
+ require.NoError(t, err)
+
+ err = service.DeleteApiKey(ctx, created.ApiKey.ID)
+ require.ErrorIs(t, err, ErrApiKeyProtected)
+
+ apiKeys := listAPIKeysForUser(t, db, adminUser.ID)
+ require.Len(t, apiKeys, 1)
+ require.Equal(t, created.ApiKey.ID, apiKeys[0].ID)
+}
+
+func TestUpdateApiKeyRejectsStaticKey(t *testing.T) {
+ ctx := context.Background()
+ service, db, userService := setupAPIKeyService(t)
+ adminUser := createDefaultAdminUser(t, ctx, userService)
+
+ created, err := service.CreateDefaultAdminAPIKey(ctx, adminUser.ID, "arc_bootstrapupdateprotected1234567890")
+ require.NoError(t, err)
+
+ name := "renamed"
+ description := "updated description"
+ updated, err := service.UpdateApiKey(ctx, created.ApiKey.ID, apikey.UpdateApiKey{
+ Name: &name,
+ Description: &description,
+ })
+ require.Nil(t, updated)
+ require.ErrorIs(t, err, ErrApiKeyProtected)
+
+ apiKeys := listAPIKeysForUser(t, db, adminUser.ID)
+ require.Len(t, apiKeys, 1)
+ require.Equal(t, defaultAdminAPIKeyName, apiKeys[0].Name)
+ require.NotNil(t, apiKeys[0].Description)
+ require.Equal(t, *defaultAdminAPIKeyDescription, *apiKeys[0].Description)
+}
+
+func TestReconcileDefaultAdminAPIKeyNoOpWhenUnchanged(t *testing.T) {
+ ctx := context.Background()
+ service, db, userService := setupAPIKeyService(t)
+ adminUser := createDefaultAdminUser(t, ctx, userService)
+
+ rawKey := "arc_bootstrapstable1234567890"
+ require.NoError(t, service.ReconcileDefaultAdminAPIKey(ctx, rawKey))
+ first := listAPIKeysForUser(t, db, adminUser.ID)
+ require.Len(t, first, 1)
+
+ require.NoError(t, service.ReconcileDefaultAdminAPIKey(ctx, rawKey))
+ second := listAPIKeysForUser(t, db, adminUser.ID)
+ require.Len(t, second, 1)
+ require.Equal(t, first[0].ID, second[0].ID)
+}
+
+func TestReconcileDefaultAdminAPIKeyReplacesManagedKeyOnRotation(t *testing.T) {
+ ctx := context.Background()
+ service, db, userService := setupAPIKeyService(t)
+ adminUser := createDefaultAdminUser(t, ctx, userService)
+
+ oldKey := "arc_bootstrapoldvalue1234567890"
+ newKey := "arc_bootstrapnewvalue1234567890"
+ require.NoError(t, service.ReconcileDefaultAdminAPIKey(ctx, oldKey))
+ first := listAPIKeysForUser(t, db, adminUser.ID)
+ require.Len(t, first, 1)
+
+ require.NoError(t, service.ReconcileDefaultAdminAPIKey(ctx, newKey))
+ second := listAPIKeysForUser(t, db, adminUser.ID)
+ require.Len(t, second, 1)
+ require.NotEqual(t, first[0].ID, second[0].ID)
+
+ _, err := service.ValidateApiKey(ctx, oldKey)
+ require.ErrorIs(t, err, ErrApiKeyInvalid)
+
+ validatedUser, err := service.ValidateApiKey(ctx, newKey)
+ require.NoError(t, err)
+ require.Equal(t, adminUser.ID, validatedUser.ID)
+}
+
+func TestReconcileDefaultAdminAPIKeyDeletesManagedKeyWhenUnset(t *testing.T) {
+ ctx := context.Background()
+ service, db, userService := setupAPIKeyService(t)
+ adminUser := createDefaultAdminUser(t, ctx, userService)
+
+ require.NoError(t, service.ReconcileDefaultAdminAPIKey(ctx, "arc_bootstrapdelete1234567890"))
+ require.Len(t, listAPIKeysForUser(t, db, adminUser.ID), 1)
+
+ require.NoError(t, service.ReconcileDefaultAdminAPIKey(ctx, ""))
+ require.Empty(t, listAPIKeysForUser(t, db, adminUser.ID))
+}
+
+func TestReconcileDefaultAdminAPIKeyPreservesUserManagedKeys(t *testing.T) {
+ ctx := context.Background()
+ service, db, userService := setupAPIKeyService(t)
+ adminUser := createDefaultAdminUser(t, ctx, userService)
+
+ userCreated, err := service.CreateApiKey(ctx, adminUser.ID, apikey.CreateApiKey{Name: "manual-key"})
+ require.NoError(t, err)
+
+ require.NoError(t, service.ReconcileDefaultAdminAPIKey(ctx, "arc_bootstrapmanualsafe1234567890"))
+
+ apiKeys := listAPIKeysForUser(t, db, adminUser.ID)
+ require.Len(t, apiKeys, 2)
+
+ foundUserKey := false
+ foundManagedKey := false
+ for _, apiKey := range apiKeys {
+ if apiKey.ID == userCreated.ApiKey.ID {
+ foundUserKey = true
+ require.Nil(t, apiKey.ManagedBy)
+ require.Equal(t, "manual-key", apiKey.Name)
+ }
+ if apiKey.ManagedBy != nil && *apiKey.ManagedBy == managedByAdminBootstrap {
+ foundManagedKey = true
+ }
+ }
+
+ require.True(t, foundUserKey)
+ require.True(t, foundManagedKey)
+}
+
+func TestReconcileDefaultAdminAPIKeyDeletesDuplicateManagedKeys(t *testing.T) {
+ ctx := context.Background()
+ service, db, userService := setupAPIKeyService(t)
+ adminUser := createDefaultAdminUser(t, ctx, userService)
+
+ rawKey := "arc_bootstrapduplicate1234567890"
+ first, err := service.CreateDefaultAdminAPIKey(ctx, adminUser.ID, rawKey)
+ require.NoError(t, err)
+ _, err = service.CreateDefaultAdminAPIKey(ctx, adminUser.ID, rawKey)
+ require.NoError(t, err)
+
+ require.NoError(t, service.ReconcileDefaultAdminAPIKey(ctx, rawKey))
+
+ apiKeys := listAPIKeysForUser(t, db, adminUser.ID)
+ require.Len(t, apiKeys, 1)
+ require.Equal(t, first.ApiKey.ID, apiKeys[0].ID)
+}
+
+func TestReconcileDefaultAdminAPIKeySkipsWhenDefaultAdminMissing(t *testing.T) {
+ ctx := context.Background()
+ service, db, _ := setupAPIKeyService(t)
+
+ err := service.ReconcileDefaultAdminAPIKey(ctx, "arc_bootstrapmissing1234567890")
+ require.NoError(t, err)
+
+ var count int64
+ err = db.WithContext(ctx).Model(&models.ApiKey{}).Count(&count).Error
+ require.NoError(t, err)
+ require.Zero(t, count)
+}
+
+func TestReconcileDefaultAdminAPIKeyRejectsInvalidKey(t *testing.T) {
+ ctx := context.Background()
+ service, db, userService := setupAPIKeyService(t)
+ adminUser := createDefaultAdminUser(t, ctx, userService)
+
+ err := service.ReconcileDefaultAdminAPIKey(ctx, "invalid-key")
+ require.ErrorIs(t, err, ErrApiKeyInvalid)
+ require.Empty(t, listAPIKeysForUser(t, db, adminUser.ID))
+}
+
func TestValidateAPIKeyUpdatesLastUsedAt(t *testing.T) {
ctx := context.Background()
service, db, userService := setupAPIKeyService(t)
@@ -154,6 +381,14 @@ func TestValidateAPIKeyInvalidDoesNotUpdateLastUsedAt(t *testing.T) {
require.Nil(t, apiKey.LastUsedAt)
}
+func TestValidateAPIKeyRejectsShortPrefixedInput(t *testing.T) {
+ ctx := context.Background()
+ service, _, _ := setupAPIKeyService(t)
+
+ _, err := service.ValidateApiKey(ctx, "arc_123")
+ require.ErrorIs(t, err, ErrApiKeyInvalid)
+}
+
func TestGetEnvironmentByAPIKeyExpiredDoesNotUpdateLastUsedAt(t *testing.T) {
ctx := context.Background()
service, db, userService := setupAPIKeyService(t)
diff --git a/backend/pkg/libarcane/startup/startup.go b/backend/pkg/libarcane/startup/startup.go
index 7ce34f95b..f554f7f33 100644
--- a/backend/pkg/libarcane/startup/startup.go
+++ b/backend/pkg/libarcane/startup/startup.go
@@ -17,6 +17,7 @@ type RuntimeConfig struct {
Environment string
EncryptionKey string
AutoLoginUsername string
+ AdminStaticAPIKey string
}
func LoadAgentToken(ctx context.Context, cfg *RuntimeConfig, getSettingFunc func(context.Context, string, string) string) {
@@ -82,7 +83,15 @@ func TestDockerConnection(ctx context.Context, testFunc func(context.Context) er
}
}
-func InitializeNonAgentFeatures(ctx context.Context, cfg *RuntimeConfig, createAdminFunc func(context.Context) error, autoLoginInitFunc func(context.Context) error, migrateOidcFunc func(context.Context) error, migrateDiscordFunc func(context.Context) error) {
+func InitializeNonAgentFeatures(
+ ctx context.Context,
+ cfg *RuntimeConfig,
+ createAdminFunc func(context.Context) error,
+ reconcileDefaultAdminAPIKeyFunc func(context.Context) error,
+ autoLoginInitFunc func(context.Context) error,
+ migrateOidcFunc func(context.Context) error,
+ migrateDiscordFunc func(context.Context) error,
+) {
if cfg.AgentMode {
return
}
@@ -91,6 +100,12 @@ func InitializeNonAgentFeatures(ctx context.Context, cfg *RuntimeConfig, createA
slog.WarnContext(ctx, "Failed to create default admin user", "error", err.Error())
}
+ if reconcileDefaultAdminAPIKeyFunc != nil {
+ if err := reconcileDefaultAdminAPIKeyFunc(ctx); err != nil {
+ slog.WarnContext(ctx, "Failed to reconcile default admin API key", "error", err.Error())
+ }
+ }
+
if err := autoLoginInitFunc(ctx); err != nil {
slog.WarnContext(ctx, "Failed to initialize auto-login", "error", err.Error())
}
diff --git a/backend/pkg/libarcane/startup/startup_test.go b/backend/pkg/libarcane/startup/startup_test.go
index 82128fc0f..7c027eb24 100644
--- a/backend/pkg/libarcane/startup/startup_test.go
+++ b/backend/pkg/libarcane/startup/startup_test.go
@@ -256,19 +256,26 @@ func TestInitializeNonAgentFeatures(t *testing.T) {
t.Run("skips in agent mode", func(t *testing.T) {
cfg := &RuntimeConfig{AgentMode: true}
createAdminCalled := false
+ reconcileDefaultAdminAPIKeyCalled := false
createAdminFunc := func(ctx context.Context) error {
createAdminCalled = true
return nil
}
+ reconcileDefaultAdminAPIKeyFunc := func(ctx context.Context) error {
+ reconcileDefaultAdminAPIKeyCalled = true
+ return nil
+ }
- InitializeNonAgentFeatures(ctx, cfg, createAdminFunc, nil, nil, nil)
+ InitializeNonAgentFeatures(ctx, cfg, createAdminFunc, reconcileDefaultAdminAPIKeyFunc, nil, nil, nil)
assert.False(t, createAdminCalled)
+ assert.False(t, reconcileDefaultAdminAPIKeyCalled)
})
t.Run("calls all functions in non-agent mode", func(t *testing.T) {
cfg := &RuntimeConfig{AgentMode: false}
createAdminCalled := false
+ reconcileDefaultAdminAPIKeyCalled := false
migrateOidcCalled := false
migrateDiscordCalled := false
autoLoginInitCalled := false
@@ -277,6 +284,10 @@ func TestInitializeNonAgentFeatures(t *testing.T) {
createAdminCalled = true
return nil
}
+ reconcileDefaultAdminAPIKeyFunc := func(ctx context.Context) error {
+ reconcileDefaultAdminAPIKeyCalled = true
+ return nil
+ }
autoLoginInitFunc := func(ctx context.Context) error {
autoLoginInitCalled = true
return nil
@@ -290,9 +301,10 @@ func TestInitializeNonAgentFeatures(t *testing.T) {
return nil
}
- InitializeNonAgentFeatures(ctx, cfg, createAdminFunc, autoLoginInitFunc, migrateOidcFunc, migrateDiscordFunc)
+ InitializeNonAgentFeatures(ctx, cfg, createAdminFunc, reconcileDefaultAdminAPIKeyFunc, autoLoginInitFunc, migrateOidcFunc, migrateDiscordFunc)
assert.True(t, createAdminCalled)
+ assert.True(t, reconcileDefaultAdminAPIKeyCalled)
assert.True(t, migrateOidcCalled)
assert.True(t, migrateDiscordCalled)
assert.True(t, autoLoginInitCalled)
@@ -300,6 +312,9 @@ func TestInitializeNonAgentFeatures(t *testing.T) {
t.Run("handles errors gracefully", func(t *testing.T) {
cfg := &RuntimeConfig{AgentMode: false}
+ reconcileDefaultAdminAPIKeyFunc := func(ctx context.Context) error {
+ return errors.New("api key reconcile failed")
+ }
autoLoginInitFunc := func(ctx context.Context) error {
return errors.New("autologin init failed")
}
@@ -313,7 +328,7 @@ func TestInitializeNonAgentFeatures(t *testing.T) {
return errors.New("discord migration failed")
}
- InitializeNonAgentFeatures(ctx, cfg, createAdminFunc, autoLoginInitFunc, migrateOidcFunc, migrateDiscordFunc)
+ InitializeNonAgentFeatures(ctx, cfg, createAdminFunc, reconcileDefaultAdminAPIKeyFunc, autoLoginInitFunc, migrateOidcFunc, migrateDiscordFunc)
})
}
diff --git a/backend/resources/migrations/postgres/040_add_api_key_managed_by.down.sql b/backend/resources/migrations/postgres/040_add_api_key_managed_by.down.sql
new file mode 100644
index 000000000..7d044ed5c
--- /dev/null
+++ b/backend/resources/migrations/postgres/040_add_api_key_managed_by.down.sql
@@ -0,0 +1 @@
+ALTER TABLE api_keys DROP COLUMN IF EXISTS managed_by;
diff --git a/backend/resources/migrations/postgres/040_add_api_key_managed_by.up.sql b/backend/resources/migrations/postgres/040_add_api_key_managed_by.up.sql
new file mode 100644
index 000000000..e777834e1
--- /dev/null
+++ b/backend/resources/migrations/postgres/040_add_api_key_managed_by.up.sql
@@ -0,0 +1 @@
+ALTER TABLE api_keys ADD COLUMN IF NOT EXISTS managed_by TEXT;
diff --git a/backend/resources/migrations/sqlite/040_add_api_key_managed_by.down.sql b/backend/resources/migrations/sqlite/040_add_api_key_managed_by.down.sql
new file mode 100644
index 000000000..9f52fd0a7
--- /dev/null
+++ b/backend/resources/migrations/sqlite/040_add_api_key_managed_by.down.sql
@@ -0,0 +1,51 @@
+DROP TABLE IF EXISTS api_keys_old;
+
+CREATE TABLE api_keys_old (
+ id TEXT PRIMARY KEY,
+ name TEXT NOT NULL,
+ description TEXT,
+ key_hash TEXT NOT NULL,
+ key_prefix TEXT NOT NULL,
+ user_id TEXT NOT NULL,
+ environment_id TEXT,
+ expires_at DATETIME,
+ last_used_at DATETIME,
+ created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+ updated_at DATETIME,
+ FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE,
+ FOREIGN KEY (environment_id) REFERENCES environments(id) ON DELETE CASCADE
+);
+
+INSERT INTO api_keys_old (
+ id,
+ name,
+ description,
+ key_hash,
+ key_prefix,
+ user_id,
+ environment_id,
+ expires_at,
+ last_used_at,
+ created_at,
+ updated_at
+)
+SELECT
+ id,
+ name,
+ description,
+ key_hash,
+ key_prefix,
+ user_id,
+ environment_id,
+ expires_at,
+ last_used_at,
+ created_at,
+ updated_at
+FROM api_keys;
+
+DROP TABLE api_keys;
+ALTER TABLE api_keys_old RENAME TO api_keys;
+
+CREATE INDEX IF NOT EXISTS idx_api_keys_user_id ON api_keys(user_id);
+CREATE INDEX IF NOT EXISTS idx_api_keys_key_hash ON api_keys(key_hash);
+CREATE INDEX IF NOT EXISTS idx_api_keys_key_prefix ON api_keys(key_prefix);
diff --git a/backend/resources/migrations/sqlite/040_add_api_key_managed_by.up.sql b/backend/resources/migrations/sqlite/040_add_api_key_managed_by.up.sql
new file mode 100644
index 000000000..c2d4dca3e
--- /dev/null
+++ b/backend/resources/migrations/sqlite/040_add_api_key_managed_by.up.sql
@@ -0,0 +1,54 @@
+-- Use create-copy-drop-rename for idempotent column additions in SQLite
+-- (SQLite lacks ADD COLUMN IF NOT EXISTS).
+DROP TABLE IF EXISTS api_keys_new;
+
+CREATE TABLE api_keys_new (
+ id TEXT PRIMARY KEY,
+ name TEXT NOT NULL,
+ description TEXT,
+ key_hash TEXT NOT NULL,
+ key_prefix TEXT NOT NULL,
+ managed_by TEXT,
+ user_id TEXT NOT NULL,
+ environment_id TEXT,
+ expires_at DATETIME,
+ last_used_at DATETIME,
+ created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+ updated_at DATETIME,
+ FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE,
+ FOREIGN KEY (environment_id) REFERENCES environments(id) ON DELETE CASCADE
+);
+
+INSERT INTO api_keys_new (
+ id,
+ name,
+ description,
+ key_hash,
+ key_prefix,
+ user_id,
+ environment_id,
+ expires_at,
+ last_used_at,
+ created_at,
+ updated_at
+)
+SELECT
+ id,
+ name,
+ description,
+ key_hash,
+ key_prefix,
+ user_id,
+ environment_id,
+ expires_at,
+ last_used_at,
+ created_at,
+ updated_at
+FROM api_keys;
+
+DROP TABLE api_keys;
+ALTER TABLE api_keys_new RENAME TO api_keys;
+
+CREATE INDEX IF NOT EXISTS idx_api_keys_user_id ON api_keys(user_id);
+CREATE INDEX IF NOT EXISTS idx_api_keys_key_hash ON api_keys(key_hash);
+CREATE INDEX IF NOT EXISTS idx_api_keys_key_prefix ON api_keys(key_prefix);
diff --git a/cli/pkg/generate/api_key.go b/cli/pkg/generate/api_key.go
new file mode 100644
index 000000000..f19013a5a
--- /dev/null
+++ b/cli/pkg/generate/api_key.go
@@ -0,0 +1,46 @@
+package generate
+
+import (
+ crand "crypto/rand"
+ "encoding/hex"
+ "fmt"
+
+ "github.com/spf13/cobra"
+)
+
+const (
+ apiKeyPrefix = "arc_"
+ apiKeyLength = 32
+)
+
+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.`,
+ RunE: func(cmd *cobra.Command, args []string) error {
+ return generateAPIKeyOutputInternal()
+ },
+}
+
+func init() {
+ GenerateCmd.AddCommand(apiKeyCmd)
+}
+
+func GenerateAPIKey() (string, error) {
+ keyBytes := make([]byte, apiKeyLength)
+ if _, err := crand.Read(keyBytes); err != nil {
+ return "", fmt.Errorf("failed to generate API key: %w", err)
+ }
+
+ return apiKeyPrefix + hex.EncodeToString(keyBytes), nil
+}
+
+func generateAPIKeyOutputInternal() error {
+ apiKey, err := GenerateAPIKey()
+ if err != nil {
+ return err
+ }
+
+ fmt.Println(apiKey)
+ return nil
+}
diff --git a/cli/pkg/generate/api_key_test.go b/cli/pkg/generate/api_key_test.go
new file mode 100644
index 000000000..0c7fec83c
--- /dev/null
+++ b/cli/pkg/generate/api_key_test.go
@@ -0,0 +1,45 @@
+package generate_test
+
+import (
+ "strings"
+ "testing"
+
+ gen "github.com/getarcaneapp/arcane/cli/pkg/generate"
+)
+
+func TestAPIKeyDefaultOutput(t *testing.T) {
+ cmd := gen.GenerateCmd
+ cmd.SetArgs([]string{"api-key"})
+
+ out, err := captureOutput(func() error {
+ _, err := cmd.ExecuteC()
+ return err
+ })
+ if err != nil {
+ t.Fatalf("command failed: %v", err)
+ }
+
+ if strings.TrimSpace(out) == "" {
+ t.Fatalf("expected raw arc_ key in output, got: %q", out)
+ }
+ if !strings.HasPrefix(strings.TrimSpace(out), "arc_") {
+ t.Fatalf("expected raw arc_ key in output, got: %q", out)
+ }
+ if strings.Contains(out, "ADMIN_STATIC_API_KEY") {
+ t.Fatalf("expected raw arc_ key in output, got: %q", out)
+ }
+}
+
+func TestGenerateAPIKeyProducesArcanePrefix(t *testing.T) {
+ apiKey, err := gen.GenerateAPIKey()
+ if err != nil {
+ t.Fatalf("GenerateAPIKey failed: %v", err)
+ }
+
+ if !strings.HasPrefix(apiKey, "arc_") {
+ t.Fatalf("expected arc_ prefix, got %q", apiKey)
+ }
+ if len(apiKey) != 68 {
+ t.Fatalf("expected 68-character key, got %d (%q)", len(apiKey), apiKey)
+ }
+}
diff --git a/cli/pkg/generate/generate.go b/cli/pkg/generate/generate.go
index 55e36b104..cdaf9dfa0 100644
--- a/cli/pkg/generate/generate.go
+++ b/cli/pkg/generate/generate.go
@@ -7,5 +7,5 @@ import (
var GenerateCmd = &cobra.Command{
Use: "generate",
Aliases: []string{"gen", "g"},
- Short: "Generate secrets for arcanes backend",
+ Short: "Generate secrets and bootstrap credentials for Arcane",
}
diff --git a/frontend/messages/en.json b/frontend/messages/en.json
index b4db7517b..4cfabe0bd 100644
--- a/frontend/messages/en.json
+++ b/frontend/messages/en.json
@@ -2038,8 +2038,12 @@
"api_key_delete_selected_message": "Are you sure you want to delete {count} API key(s)? This action cannot be undone.",
"api_key_delete_failed": "Failed to delete API key \"{name}\"",
"api_key_delete_success": "API key \"{name}\" deleted successfully",
+ "api_key_static_title": "Static Admin API Key",
+ "api_key_static_description": "This API key is managed by ADMIN_STATIC_API_KEY and cannot be edited or deleted from the UI.",
"api_key_bulk_delete_success": "Successfully deleted {count} API key(s)",
"api_key_bulk_delete_failed": "Failed to delete {count} API key(s)",
+ "api_key_bulk_delete_static_skipped": "Skipped {count} static API key(s). Only deletable keys will be removed.",
+ "api_key_bulk_delete_static_only": "Static API keys cannot be deleted.",
"common_done": "Done",
"common_important": "Important",
"select_a_date": "Select a date",
diff --git a/frontend/src/lib/components/form/date-picker.svelte b/frontend/src/lib/components/form/date-picker.svelte
index 0e984a3d9..75830340d 100644
--- a/frontend/src/lib/components/form/date-picker.svelte
+++ b/frontend/src/lib/components/form/date-picker.svelte
@@ -12,9 +12,10 @@
type Props = {
value?: Date;
id?: string;
+ disabled?: boolean;
} & HTMLAttributes<HTMLDivElement>;
- let { value = $bindable(undefined), id, ...restProps }: Props = $props();
+ let { value = $bindable(undefined), id, disabled = false, ...restProps }: Props = $props();
let calendarDisplayDate: CalendarDate | undefined = $state(value ? dateToCalendarDate(value) : undefined);
@@ -71,6 +72,7 @@
aria-label={m.select_a_date()}
icon={CalendarIcon}
customLabel={calendarDisplayDate ? df.format(calendarDisplayDate.toDate(getLocalTimeZone())) : m.select_a_date()}
+ {disabled}
/>
{/snippet}
</Popover.Trigger>
diff --git a/frontend/src/lib/components/form/form-input.svelte b/frontend/src/lib/components/form/form-input.svelte
index a705f3430..1dc3d1e2b 100644
--- a/frontend/src/lib/components/form/form-input.svelte
+++ b/frontend/src/lib/components/form/form-input.svelte
@@ -55,7 +55,7 @@
{:else if type === 'textarea'}
<Textarea {id} {placeholder} {rows} bind:value={input.value as string} {disabled} />
{:else if type === 'date'}
- <DatePicker {id} bind:value={input.value as Date} />
+ <DatePicker {id} bind:value={input.value as Date} {disabled} />
{:else}
<Input {id} {placeholder} {type} bind:value={input.value} {disabled} {autocomplete} />
{/if}
diff --git a/frontend/src/lib/components/sheets/api-key-form-sheet.svelte b/frontend/src/lib/components/sheets/api-key-form-sheet.svelte
index ea8f58bba..fca4d179d 100644
--- a/frontend/src/lib/components/sheets/api-key-form-sheet.svelte
+++ b/frontend/src/lib/components/sheets/api-key-form-sheet.svelte
@@ -2,12 +2,10 @@
import * as ResponsiveDialog from '$lib/components/ui/responsive-dialog/index.js';
import { ArcaneButton } from '$lib/components/arcane-button/index.js';
import FormInput from '$lib/components/form/form-input.svelte';
- import { Spinner } from '$lib/components/ui/spinner/index.js';
import type { ApiKey } from '$lib/types/api-key.type';
import { z } from 'zod/v4';
import { createForm, preventDefault } from '$lib/utils/form.utils';
import * as m from '$lib/paraglide/messages.js';
- import { ApiKeyIcon, SaveIcon } from '$lib/icons';
type ApiKeyFormProps = {
open: boolean;
@@ -23,7 +21,7 @@
let { open = $bindable(false), apiKeyToEdit = $bindable(), onSubmit, isLoading }: ApiKeyFormProps = $props();
let isEditMode = $derived(!!apiKeyToEdit);
- let SubmitIcon = $derived(isEditMode ? SaveIcon : ApiKeyIcon);
+ let isStaticApiKey = $derived(apiKeyToEdit?.isStatic ?? false);
const formSchema = z.object({
name: z.string().min(1, m.common_field_required({ field: m.api_key_name() })),
@@ -40,6 +38,8 @@
let { inputs, ...form } = $derived(createForm<typeof formSchema>(formSchema, formData));
function handleSubmit() {
+ if (isStaticApiKey) return;
+
const data = form.validate();
if (!data) return;
@@ -64,9 +64,15 @@
bind:open
onOpenChange={handleOpenChange}
variant="sheet"
- title={isEditMode ? m.api_key_edit_title() : m.api_key_create_title()}
+ title={isStaticApiKey
+ ? (apiKeyToEdit?.name ?? m.api_key_static_title())
+ : isEditMode
+ ? m.api_key_edit_title()
+ : m.api_key_create_title()}
description={isEditMode
- ? m.api_key_edit_description({ name: apiKeyToEdit?.name ?? m.common_unknown() })
+ ? isStaticApiKey
+ ? m.api_key_static_description()
+ : m.api_key_edit_description({ name: apiKeyToEdit?.name ?? m.common_unknown() })
: m.api_key_create_description()}
contentClass="sm:max-w-[500px]"
>
@@ -78,6 +84,7 @@
placeholder={m.api_key_name_placeholder()}
description={m.api_key_name_description()}
bind:input={$inputs.name}
+ disabled={isStaticApiKey}
/>
<FormInput
label={m.api_key_description_label()}
@@ -85,12 +92,14 @@
placeholder={m.api_key_description_placeholder()}
description={m.api_key_description_help()}
bind:input={$inputs.description}
+ disabled={isStaticApiKey}
/>
<FormInput
label={m.api_key_expires_at()}
type="date"
description={m.api_key_expires_at_description()}
bind:input={$inputs.expiresAt}
+ disabled={isStaticApiKey}
/>
</form>
{/snippet}
@@ -105,15 +114,17 @@
onclick={() => (open = false)}
disabled={isLoading}
/>
- <ArcaneButton
- action={isEditMode ? 'save' : 'create'}
- type="submit"
- class="flex-1"
- disabled={isLoading}
- loading={isLoading}
- onclick={handleSubmit}
- customLabel={isEditMode ? m.api_key_save_changes() : m.api_key_create_button()}
- />
+ {#if !isStaticApiKey}
+ <ArcaneButton
+ action={isEditMode ? 'save' : 'create'}
+ type="submit"
+ class="flex-1"
+ disabled={isLoading}
+ loading={isLoading}
+ onclick={handleSubmit}
+ customLabel={isEditMode ? m.api_key_save_changes() : m.api_key_create_button()}
+ />
+ {/if}
</div>
{/snippet}
</ResponsiveDialog.Root>
diff --git a/frontend/src/lib/types/api-key.type.ts b/frontend/src/lib/types/api-key.type.ts
index 5e5c90957..0ebc124b1 100644
--- a/frontend/src/lib/types/api-key.type.ts
+++ b/frontend/src/lib/types/api-key.type.ts
@@ -4,6 +4,7 @@ export type ApiKey = {
description?: string;
keyPrefix: string;
userId: string;
+ isStatic: boolean;
expiresAt?: string;
lastUsedAt?: string;
createdAt: string;
diff --git a/frontend/src/routes/(app)/settings/api-keys/api-key-table.svelte b/frontend/src/routes/(app)/settings/api-keys/api-key-table.svelte
index 682dff157..e63285410 100644
--- a/frontend/src/routes/(app)/settings/api-keys/api-key-table.svelte
+++ b/frontend/src/routes/(app)/settings/api-keys/api-key-table.svelte
@@ -54,12 +54,30 @@
return 'green';
}
+ function isStaticApiKey(apiKey: ApiKey): boolean {
+ return apiKey.isStatic;
+ }
+
+ const selectedStaticApiKeyCount = $derived.by(
+ () => apiKeys.data.filter((apiKey) => selectedIds.includes(apiKey.id) && isStaticApiKey(apiKey)).length
+ );
+ const selectedDeletableApiKeyIds = $derived.by(() =>
+ apiKeys.data.filter((apiKey) => selectedIds.includes(apiKey.id) && !isStaticApiKey(apiKey)).map((apiKey) => apiKey.id)
+ );
+
async function handleDeleteSelected() {
if (selectedIds.length === 0) return;
+ if (selectedDeletableApiKeyIds.length === 0) {
+ toast.info(m.api_key_bulk_delete_static_only());
+ return;
+ }
+ if (selectedStaticApiKeyCount > 0) {
+ toast.info(m.api_key_bulk_delete_static_skipped({ count: selectedStaticApiKeyCount }));
+ }
openConfirmDialog({
- title: m.api_key_delete_selected_title({ count: selectedIds.length }),
- message: m.api_key_delete_selected_message({ count: selectedIds.length }),
+ title: m.api_key_delete_selected_title({ count: selectedDeletableApiKeyIds.length }),
+ message: m.api_key_delete_selected_message({ count: selectedDeletableApiKeyIds.length }),
confirm: {
label: m.common_delete(),
destructive: true,
@@ -68,7 +86,7 @@
let successCount = 0;
let failureCount = 0;
- for (const apiKeyId of selectedIds) {
+ for (const apiKeyId of selectedDeletableApiKeyIds) {
const result = await tryCatch(apiKeyService.delete(apiKeyId));
handleApiResultWithCallbacks({
result,
@@ -147,7 +165,7 @@
action: 'remove',
onClick: handleDeleteSelected,
loading: isLoading.removing,
- disabled: isLoading.removing,
+ disabled: isLoading.removing || selectedDeletableApiKeyIds.length === 0,
icon: TrashIcon
}
]);
@@ -242,14 +260,17 @@
</DropdownMenu.Trigger>
<DropdownMenu.Content align="end">
<DropdownMenu.Group>
- <DropdownMenu.Item onclick={() => onEditApiKey(item)}>
+ <DropdownMenu.Item onclick={() => onEditApiKey(item)} disabled={isStaticApiKey(item)}>
<EditIcon class="size-4" />
{m.common_edit()}
</DropdownMenu.Item>
-
<DropdownMenu.Separator />
- <DropdownMenu.Item variant="destructive" onclick={() => handleDeleteApiKey(item.id, item.name)}>
+ <DropdownMenu.Item
+ variant="destructive"
+ onclick={() => handleDeleteApiKey(item.id, item.name)}
+ disabled={isStaticApiKey(item)}
+ >
<TrashIcon class="size-4" />
{m.common_delete()}
</DropdownMenu.Item>
diff --git a/types/apikey/apikey.go b/types/apikey/apikey.go
index 544d941d8..75cdcb8d3 100644
--- a/types/apikey/apikey.go
+++ b/types/apikey/apikey.go
@@ -16,6 +16,7 @@ type ApiKey struct {
Description *string `json:"description,omitempty" doc:"Description of the API key"`
KeyPrefix string `json:"keyPrefix" doc:"Prefix of the API key for identification"`
UserID string `json:"userId" doc:"ID of the user who owns the API key"`
+ IsStatic bool `json:"isStatic" doc:"Whether the API key is environment-managed and protected from deletion"`
ExpiresAt *time.Time `json:"expiresAt,omitempty" doc:"Expiration date of the API key"`
LastUsedAt *time.Time `json:"lastUsedAt,omitempty" doc:"Last time the API key was used"`
CreatedAt time.Time `json:"createdAt" doc:"Creation timestamp"`