Skip to content

Modern Docker Management, Designed for Everyone

fix: add generate command back to built in cli

Kyle Mendell875a96a5ec75
diff --git a/backend/cli/generate/generate.go b/backend/cli/generate/generate.go
new file mode 100644
index 000000000..55e36b104
--- /dev/null
+++ b/backend/cli/generate/generate.go
@@ -0,0 +1,11 @@
+package generate
+
+import (
+ "github.com/spf13/cobra"
+)
+
+var GenerateCmd = &cobra.Command{
+ Use: "generate",
+ Aliases: []string{"gen", "g"},
+ Short: "Generate secrets for arcanes backend",
+}
diff --git a/backend/cli/generate/secret.go b/backend/cli/generate/secret.go
new file mode 100644
index 000000000..4297ba39b
--- /dev/null
+++ b/backend/cli/generate/secret.go
@@ -0,0 +1,113 @@
+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/cli/generate/secret_test.go b/backend/cli/generate/secret_test.go
new file mode 100644
index 000000000..dd7eaa038
--- /dev/null
+++ b/backend/cli/generate/secret_test.go
@@ -0,0 +1,143 @@
+package generate
+
+import (
+ "bytes"
+ "encoding/base64"
+ "encoding/hex"
+ "io"
+ "os"
+ "strings"
+ "testing"
+)
+
+// captureOutput captures stdout produced by fn and returns it as a string.
+func captureOutput(fn func() error) (string, error) {
+ // Save original
+ oldOut := os.Stdout
+ r, w, err := os.Pipe()
+ if err != nil {
+ return "", err
+ }
+ os.Stdout = w
+
+ // Run function
+ runErr := fn()
+
+ // Restore
+ _ = w.Close()
+ os.Stdout = oldOut
+
+ var buf bytes.Buffer
+ _, _ = io.Copy(&buf, r)
+ _ = r.Close()
+ return buf.String(), runErr
+}
+
+func TestSecretDefaultBase64(t *testing.T) {
+ cmd := GenerateCmd
+ cmd.SetArgs([]string{"secret"})
+
+ out, err := captureOutput(func() error {
+ _, err := cmd.ExecuteC()
+ return err
+ })
+ if err != nil {
+ t.Fatalf("command failed: %v", err)
+ }
+
+ // should not include emoji characters used previously
+ if strings.Contains(out, "πŸ“‹") || strings.Contains(out, "🐳") || strings.Contains(out, "πŸ”’") || strings.Contains(out, "⚠️") {
+ t.Fatalf("output contains emoji/box characters: %q", out)
+ }
+
+ if !strings.Contains(out, "BASE64") {
+ t.Fatalf("expected BASE64 header in output, got: %q", out)
+ }
+
+ // find ENCRYPTION_KEY= and JWT_SECRET= lines and ensure they are valid base64
+ var encVal, jwtVal string
+ for _, line := range strings.Split(out, "\n") {
+ if strings.HasPrefix(line, "ENCRYPTION_KEY=") {
+ encVal = strings.TrimPrefix(line, "ENCRYPTION_KEY=")
+ }
+ if strings.HasPrefix(line, "JWT_SECRET=") {
+ jwtVal = strings.TrimPrefix(line, "JWT_SECRET=")
+ }
+ }
+ if encVal == "" || jwtVal == "" {
+ t.Fatalf("missing keys in output: enc=%q jwt=%q out=%q", encVal, jwtVal, out)
+ }
+
+ if b, err := base64.StdEncoding.DecodeString(encVal); err != nil {
+ t.Fatalf("ENCRYPTION_KEY is not valid base64: %v (value=%q)", err, encVal)
+ } else if len(b) != 32 {
+ t.Fatalf("ENCRYPTION_KEY decoded length != 32 bytes: %d", len(b))
+ }
+ if b, err := base64.StdEncoding.DecodeString(jwtVal); err != nil {
+ t.Fatalf("JWT_SECRET is not valid base64: %v (value=%q)", err, jwtVal)
+ } else if len(b) != 32 {
+ t.Fatalf("JWT_SECRET decoded length != 32 bytes: %d", len(b))
+ }
+}
+
+func TestSecretAllFormatContainsSections(t *testing.T) {
+ cmd := GenerateCmd
+ cmd.SetArgs([]string{"secret", "-f", "all"})
+
+ out, err := captureOutput(func() error {
+ _, err := cmd.ExecuteC()
+ return err
+ })
+ if err != nil {
+ t.Fatalf("command failed: %v", err)
+ }
+
+ if strings.Contains(out, "πŸ“‹") || strings.Contains(out, "🐳") || strings.Contains(out, "πŸ”’") || strings.Contains(out, "⚠️") {
+ t.Fatalf("output contains emoji/box characters: %q", out)
+ }
+
+ // verify presence of expected section headers
+ mustContain := []string{
+ "ENV (.env) - recommended",
+ "Docker Compose (environment block)",
+ "HEX",
+ }
+ for _, s := range mustContain {
+ if !strings.Contains(out, s) {
+ t.Fatalf("expected section %q not found in output:\n%s", s, out)
+ }
+ }
+
+ // verify hex values decode to 32 bytes
+ var hexEnc, hexJwt string
+ for _, line := range strings.Split(out, "\n") {
+ if strings.HasPrefix(line, "ENCRYPTION_KEY=") {
+ v := strings.TrimPrefix(line, "ENCRYPTION_KEY=")
+ // prefer hex if line length looks like hex (64 chars)
+ if len(v) >= 64 {
+ hexEnc = v
+ continue
+ }
+ }
+ if strings.HasPrefix(line, "JWT_SECRET=") {
+ v := strings.TrimPrefix(line, "JWT_SECRET=")
+ if len(v) >= 64 {
+ hexJwt = v
+ continue
+ }
+ }
+ }
+ if hexEnc == "" || hexJwt == "" {
+ t.Fatalf("hex values not found in output (enc=%q jwt=%q) output:\n%s", hexEnc, hexJwt, out)
+ }
+ if b, err := hex.DecodeString(strings.TrimSpace(hexEnc)); err != nil {
+ t.Fatalf("ENCRYPTION_KEY hex decode failed: %v", err)
+ } else if len(b) != 32 {
+ t.Fatalf("ENCRYPTION_KEY hex decoded length != 32: %d", len(b))
+ }
+ if b, err := hex.DecodeString(strings.TrimSpace(hexJwt)); err != nil {
+ t.Fatalf("JWT_SECRET hex decode failed: %v", err)
+ } else if len(b) != 32 {
+ t.Fatalf("JWT_SECRET hex decoded length != 32: %d", len(b))
+ }
+}
diff --git a/backend/cli/root.go b/backend/cli/root.go
index e0ca6c534..5b6f193cd 100644
--- a/backend/cli/root.go
+++ b/backend/cli/root.go
@@ -7,6 +7,7 @@ import (
"github.com/spf13/cobra"
+ "github.com/getarcaneapp/arcane/backend/cli/generate"
"github.com/getarcaneapp/arcane/backend/cli/upgrade"
"github.com/getarcaneapp/arcane/backend/internal/bootstrap"
"github.com/getarcaneapp/arcane/backend/internal/config"
@@ -38,6 +39,7 @@ func Execute() {
func init() {
rootCmd.AddCommand(upgrade.UpgradeCmd)
+ rootCmd.AddCommand(generate.GenerateCmd)
}
func getVersion() string {