feat: add manifest version support and validation command for cpak.json

Author: mirkobrombin

cmd/init.go

@@ -19,6 +19,8 @@ func NewInitCommand() *cobra.Command {
 	}
 
 	// flags required...
+	cmd.Flags().StringP("manifest-version", "m", "1.0", "Manifest version (default: 1.0)")
+
 	cmd.Flags().StringP("name", "n", "", "Name of the application (required)")
 	cmd.MarkFlagRequired("name")
 
@@ -43,6 +45,7 @@ func NewInitCommand() *cobra.Command {
 
 // initRun executes the scaffolding of cpak.json based on provided flags.
 func initRun(cmd *cobra.Command, args []string) error {
+	manifestVersion, _ := cmd.Flags().GetString("manifest-version")
 	name, _ := cmd.Flags().GetString("name")
 	version, _ := cmd.Flags().GetString("version")
 	desc, _ := cmd.Flags().GetString("description")
@@ -54,16 +57,17 @@ func initRun(cmd *cobra.Command, args []string) error {
 	idle, _ := cmd.Flags().GetInt("idle-time")
 
 	manifest := types.CpakManifest{
-		Name:           name,
-		Description:    desc,
-		Version:        version,
-		Image:          image,
-		Binaries:       binaries,
-		DesktopEntries: desktops,
-		Dependencies:   []types.Dependency{},
-		Addons:         addons,
-		IdleTime:       idle,
-		Override:       types.NewOverride(),
+		ManifestVersion: manifestVersion,
+		Name:            name,
+		Description:     desc,
+		Version:         version,
+		Image:           image,
+		Binaries:        binaries,
+		DesktopEntries:  desktops,
+		Dependencies:    []types.Dependency{},
+		Addons:          addons,
+		IdleTime:        idle,
+		Override:        types.NewOverride(),
 	}
 	for _, origin := range deps {
 		manifest.Dependencies = append(manifest.Dependencies, types.Dependency{Origin: origin})

cmd/validate.go

@@ -0,0 +1,55 @@
+package cmd
+
+import (
+	"encoding/json"
+	"fmt"
+
+	"github.com/invopop/jsonschema"
+	"github.com/mirkobrombin/cpak/pkg/types"
+	"github.com/spf13/cobra"
+	"github.com/xeipuuv/gojsonschema"
+)
+
+// NewValidateCommand creates the `validate` command for verifying a cpak.json
+// manifest against the JSON Schema.
+func NewValidateCommand() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "validate [manifest]",
+		Short: "Validate a cpak.json manifest against manifest.schema.json",
+		Args:  cobra.ExactArgs(1),
+		RunE:  runValidate,
+	}
+	return cmd
+}
+
+// runValidate checks the provided manifest against the JSON Schema and reports
+// any validation errors.
+func runValidate(cmd *cobra.Command, args []string) error {
+	manifestPath := args[0]
+
+	reflector := &jsonschema.Reflector{ExpandedStruct: true}
+	schema := reflector.Reflect(&types.CpakManifest{})
+
+	schemaBytes, err := json.Marshal(schema)
+	if err != nil {
+		return fmt.Errorf("failed to serialize schema: %w", err)
+	}
+	schemaLoader := gojsonschema.NewBytesLoader(schemaBytes)
+	documentLoader := gojsonschema.NewReferenceLoader("file://" + manifestPath)
+
+	result, err := gojsonschema.Validate(schemaLoader, documentLoader)
+	if err != nil {
+		return fmt.Errorf("schema validation error: %w", err)
+	}
+
+	if !result.Valid() {
+		fmt.Println("Manifest validation errors:")
+		for _, desc := range result.Errors() {
+			fmt.Printf(" - %s\n", desc)
+		}
+		return fmt.Errorf("validation failed with %d errors", len(result.Errors()))
+	}
+
+	fmt.Println("Manifest is valid against the schema.")
+	return nil
+}

main.go

@@ -36,6 +36,7 @@ func main() {
 	rootCmd.AddCommand(cmd.NewExtractCommand())
 	rootCmd.AddCommand(cmd.NewInitCommand())
 	rootCmd.AddCommand(cmd.NewGenSchemaCommand())
+	rootCmd.AddCommand(cmd.NewValidateCommand())
 	rootCmd.AddCommand(cmd.NewHostExecServerCommand())
 	rootCmd.AddCommand(cmd.NewHostExecClientCommand())
 

pkg/cpak/validator.go

@@ -4,26 +4,23 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
-	"os"
-	"path/filepath"
 	"strings"
 
+	"github.com/invopop/jsonschema"
 	"github.com/mirkobrombin/cpak/pkg/types"
 	"github.com/xeipuuv/gojsonschema"
 )
 
 // ValidateManifest validates a CpakManifest against its JSON schema.
 func ValidateManifest(m *types.CpakManifest) error {
-	exeDir, err := filepath.Abs(filepath.Dir(os.Args[0]))
+	reflector := &jsonschema.Reflector{ExpandedStruct: true}
+	schema := reflector.Reflect(&types.CpakManifest{})
+
+	schemaBytes, err := json.Marshal(schema)
 	if err != nil {
-		return fmt.Errorf("cannot locate executable dir: %w", err)
-	}
-	schemaPath := filepath.Join(exeDir, "manifest.schema.json")
-	if _, err := os.Stat(schemaPath); err != nil {
-		return fmt.Errorf("schema file not found at %s: %w", schemaPath, err)
+		return fmt.Errorf("failed to serialize JSON schema: %w", err)
 	}
-
-	schemaLoader := gojsonschema.NewReferenceLoader("file://" + schemaPath)
+	schemaLoader := gojsonschema.NewBytesLoader(schemaBytes)
 
 	manifestBytes, err := json.Marshal(m)
 	if err != nil {
@@ -35,6 +32,7 @@ func ValidateManifest(m *types.CpakManifest) error {
 	if err != nil {
 		return fmt.Errorf("schema validation error: %w", err)
 	}
+
 	if !result.Valid() {
 		var sb strings.Builder
 		sb.WriteString("manifest validation failed:\n")
@@ -45,5 +43,6 @@ func ValidateManifest(m *types.CpakManifest) error {
 		}
 		return errors.New(sb.String())
 	}
+
 	return nil
 }

pkg/types/manifest.go

@@ -7,6 +7,9 @@ package types
 
 // CpakManifest is the struct that represents the manifest of an application.
 type CpakManifest struct {
+	// ManifestVersion is the version of the manifest schema (e.g. "1.0").
+	ManifestVersion string `json:"manifest_version" jsonschema:"enum=1.0,description=Manifest schema version"`
+
 	// Name is the name of the application.
 	Name string `json:"name" jsonschema:"minLength=1,description=Application name"`