resolve discussions

mnsboev · mnsboev · commit cbc0800ee453 · 2025-07-16T13:34:42.000+03:00
diff --git a/evidence/cli/command_build.go b/evidence/cli/command_build.go
@@ -22,7 +22,7 @@ func NewEvidenceBuildCommand(ctx *components.Context, execute execCommandFunc) E
 
 func (ebc *evidenceBuildCommand) CreateEvidence(ctx *components.Context, serverDetails *config.ServerDetails) error {
 	if ebc.ctx.GetStringFlagValue(sigstoreBundle) != "" {
-		return errorutils.CheckErrorf("--sigstore-bundle is currently not supported for build evidence. This feature may be supported in future releases.")
+		return errorutils.CheckErrorf("--%s is currently not supported for build evidence.", sigstoreBundle)
 	}
 
 	err := ebc.validateEvidenceBuildContext(ctx)
diff --git a/evidence/cli/command_build_test.go b/evidence/cli/command_build_test.go
@@ -26,7 +26,7 @@ func TestEvidenceBuildCommand_CreateEvidence_SigstoreBundle(t *testing.T) {
 				setDefaultValue(buildNumber, "123"),
 			},
 			expectError:   true,
-			errorContains: "--sigstore-bundle is currently not supported for build evidence. This feature may be supported in future releases.",
+			errorContains: "--sigstore-bundle is currently not supported for build evidence.",
 		},
 		{
 			name: "Valid_Without_SigstoreBundle",
diff --git a/evidence/cli/command_cli.go b/evidence/cli/command_cli.go
@@ -120,7 +120,7 @@ func validateCreateEvidenceCommonContext(ctx *components.Context) error {
 	}
 
 	if ctx.IsFlagSet(sigstoreBundle) && assertValueProvided(ctx, sigstoreBundle) == nil {
-		if err := validateSigstoreBundleConflicts(ctx); err != nil {
+		if err := validateSigstoreBundleArgsConflicts(ctx); err != nil {
 			return err
 		}
 		return nil
@@ -144,24 +144,24 @@ func validateCreateEvidenceCommonContext(ctx *components.Context) error {
 	return nil
 }
 
-func validateSigstoreBundleConflicts(ctx *components.Context) error {
+func validateSigstoreBundleArgsConflicts(ctx *components.Context) error {
 	var conflictingParams []string
 
 	if ctx.IsFlagSet(key) && ctx.GetStringFlagValue(key) != "" {
-		conflictingParams = append(conflictingParams, "--key")
+		conflictingParams = append(conflictingParams, "--"+key)
 	}
 	if ctx.IsFlagSet(keyAlias) && ctx.GetStringFlagValue(keyAlias) != "" {
-		conflictingParams = append(conflictingParams, "--key-alias")
+		conflictingParams = append(conflictingParams, "--"+keyAlias)
 	}
 	if ctx.IsFlagSet(predicate) && ctx.GetStringFlagValue(predicate) != "" {
-		conflictingParams = append(conflictingParams, "--predicate")
+		conflictingParams = append(conflictingParams, "--"+predicate)
 	}
 	if ctx.IsFlagSet(predicateType) && ctx.GetStringFlagValue(predicateType) != "" {
-		conflictingParams = append(conflictingParams, "--predicate-type")
+		conflictingParams = append(conflictingParams, "--"+predicateType)
 	}
 
 	if len(conflictingParams) > 0 {
-		return errorutils.CheckErrorf("The following parameters cannot be used with --sigstore-bundle: %s. When using --sigstore-bundle, these values are extracted from the bundle itself.", strings.Join(conflictingParams, ", "))
+		return errorutils.CheckErrorf("The following parameters cannot be used with --%s: %s. These values are extracted from the bundle itself:", sigstoreBundle, strings.Join(conflictingParams, ", "))
 	}
 
 	return nil
@@ -238,7 +238,7 @@ func validateKeys(ctx *components.Context) error {
 	providedKeys := ctx.GetStringsArrFlagValue(publicKeys)
 	if signingKeyValue == "" {
 		if len(providedKeys) == 0 && !ctx.GetBoolFlagValue(useArtifactoryKeys) {
-			return errorutils.CheckErrorf("JFROG_CLI_SIGNING_KEY env variable or --public-keys flag or --use-artifactory-publicKeys must be provided when verifying evidence")
+			return errorutils.CheckErrorf("JFROG_CLI_SIGNING_KEY env variable or --%s flag or --%s must be provided when verifying evidence", publicKeys, useArtifactoryKeys)
 		}
 		return nil
 	}
@@ -292,7 +292,7 @@ func platformToEvidenceUrls(rtDetails *config.ServerDetails) {
 
 func assertValueProvided(c *components.Context, fieldName string) error {
 	if c.GetStringFlagValue(fieldName) == "" {
-		return errorutils.CheckErrorf("the --%s option is mandatory", fieldName)
+		return errorutils.CheckErrorf("the argument --%s can not be empty", fieldName)
 	}
 	return nil
 }
diff --git a/evidence/cli/command_cli_test.go b/evidence/cli/command_cli_test.go
@@ -586,7 +586,7 @@ func TestValidateSigstoreBundleConflicts(t *testing.T) {
 				t.Fatal(err)
 			}
 
-			err = validateSigstoreBundleConflicts(context)
+			err = validateSigstoreBundleArgsConflicts(context)
 
 			if tt.expectError {
 				assert.Error(t, err)
diff --git a/evidence/cli/command_custom.go b/evidence/cli/command_custom.go
@@ -21,7 +21,7 @@ func NewEvidenceCustomCommand(ctx *components.Context, execute execCommandFunc)
 }
 func (ecc *evidenceCustomCommand) CreateEvidence(_ *components.Context, serverDetails *config.ServerDetails) error {
 	if ecc.ctx.GetStringFlagValue(sigstoreBundle) != "" && ecc.ctx.GetStringFlagValue(subjectSha256) != "" {
-		return errorutils.CheckErrorf("The parameter --subject-sha256 cannot be used with --sigstore-bundle. When using --sigstore-bundle, the subject hash is extracted from the bundle itself.")
+		return errorutils.CheckErrorf("The parameter --%s cannot be used with --%s. The subject hash is extracted from the bundle itself.", subjectSha256, sigstoreBundle)
 	}
 
 	// Single command handles both regular evidence creation and sigstore bundles
diff --git a/evidence/cli/command_github.go b/evidence/cli/command_github.go
@@ -21,7 +21,7 @@ func NewEvidenceGitHubCommand(ctx *components.Context, execute execCommandFunc)
 
 func (ebc *evidenceGitHubCommand) CreateEvidence(ctx *components.Context, serverDetails *config.ServerDetails) error {
 	if ebc.ctx.GetStringFlagValue(sigstoreBundle) != "" {
-		return errorutils.CheckErrorf("--sigstore-bundle is currently not supported for GitHub evidence. This feature may be supported in future releases.")
+		return errorutils.CheckErrorf("--%s is currently not supported for GitHub evidence.", sigstoreBundle)
 	}
 
 	err := ebc.validateEvidenceBuildContext(ctx)
diff --git a/evidence/cli/command_github_test.go b/evidence/cli/command_github_test.go
@@ -27,7 +27,7 @@ func TestEvidenceGitHubCommand_CreateEvidence_SigstoreBundle(t *testing.T) {
 				setDefaultValue(typeFlag, "github"),
 			},
 			expectError:   true,
-			errorContains: "--sigstore-bundle is currently not supported for GitHub evidence. This feature may be supported in future releases.",
+			errorContains: "--sigstore-bundle is currently not supported for GitHub evidence.",
 		},
 		{
 			name: "Valid_Without_SigstoreBundle",
diff --git a/evidence/cli/command_package.go b/evidence/cli/command_package.go
@@ -22,7 +22,7 @@ func NewEvidencePackageCommand(ctx *components.Context, execute execCommandFunc)
 
 func (epc *evidencePackageCommand) CreateEvidence(ctx *components.Context, serverDetails *config.ServerDetails) error {
 	if epc.ctx.GetStringFlagValue(sigstoreBundle) != "" {
-		return errorutils.CheckErrorf("--sigstore-bundle is currently not supported for package evidence. This feature may be supported in future releases.")
+		return errorutils.CheckErrorf("--%s is currently not supported for package evidence.", sigstoreBundle)
 	}
 
 	err := epc.validateEvidencePackageContext(ctx)
diff --git a/evidence/cli/command_package_test.go b/evidence/cli/command_package_test.go
@@ -27,7 +27,7 @@ func TestEvidencePackageCommand_CreateEvidence_SigstoreBundle(t *testing.T) {
 				setDefaultValue(packageRepoName, "test-repo"),
 			},
 			expectError:   true,
-			errorContains: "--sigstore-bundle is currently not supported for package evidence. This feature may be supported in future releases.",
+			errorContains: "--sigstore-bundle is currently not supported for package evidence.",
 		},
 		{
 			name: "Valid_Without_SigstoreBundle",
diff --git a/evidence/cli/command_release_bundle.go b/evidence/cli/command_release_bundle.go
@@ -22,7 +22,7 @@ func NewEvidenceReleaseBundleCommand(ctx *components.Context, execute execComman
 
 func (erc *evidenceReleaseBundleCommand) CreateEvidence(ctx *components.Context, serverDetails *config.ServerDetails) error {
 	if erc.ctx.GetStringFlagValue(sigstoreBundle) != "" {
-		return errorutils.CheckErrorf("--sigstore-bundle is currently not supported for release bundle evidence. This feature may be supported in future releases.")
+		return errorutils.CheckErrorf("--%s is currently not supported for release bundle evidence.", sigstoreBundle)
 	}
 
 	err := erc.validateEvidenceReleaseBundleContext(ctx)
diff --git a/evidence/cli/command_release_bundle_test.go b/evidence/cli/command_release_bundle_test.go
@@ -26,7 +26,7 @@ func TestEvidenceReleaseBundleCommand_CreateEvidence_SigstoreBundle(t *testing.T
 				setDefaultValue(releaseBundleVersion, "1.0.0"),
 			},
 			expectError:   true,
-			errorContains: "--sigstore-bundle is currently not supported for release bundle evidence. This feature may be supported in future releases.",
+			errorContains: "--sigstore-bundle is currently not supported for release bundle evidence.",
 		},
 		{
 			name: "Valid_Without_SigstoreBundle",
diff --git a/evidence/cli/flags.go b/evidence/cli/flags.go
@@ -73,7 +73,7 @@ var flagsMap = map[string]components.Flag{
 	providerId:         components.NewStringFlag(providerId, "Provider ID for the evidence.", func(f *components.StringFlag) { f.Mandatory = false }),
 	publicKeys:         components.NewStringFlag(publicKeys, "Array of paths to public keys for signatures verification with \";\" separator. Supported keys: 'ecdsa','rsa' and 'ed25519'.", func(f *components.StringFlag) { f.Mandatory = false }),
 	useArtifactoryKeys: components.NewBoolFlag(useArtifactoryKeys, "Use Artifactory keys for verification. When enabled, the verify command retrieves keys from Artifactory.", func(f *components.BoolFlag) { f.DefaultValue = false }),
-	sigstoreBundle:     components.NewStringFlag(sigstoreBundle, "Path to a sigstore bundle file containing a pre-signed DSSE envelope", func(f *components.StringFlag) { f.Mandatory = false }),
+	sigstoreBundle:     components.NewStringFlag(sigstoreBundle, "Path to a Sigstore bundle file with a pre-signed DSSE envelope", func(f *components.StringFlag) { f.Mandatory = false }),
 }
 
 var commandFlags = map[string][]string{
diff --git a/evidence/create/create_base.go b/evidence/create/create_base.go
@@ -18,7 +18,6 @@ import (
 	"github.com/jfrog/jfrog-cli-core/v2/utils/config"
 	"github.com/jfrog/jfrog-client-go/artifactory"
 	evidenceService "github.com/jfrog/jfrog-client-go/evidence/services"
-	"github.com/jfrog/jfrog-client-go/utils/errorutils"
 	clientlog "github.com/jfrog/jfrog-client-go/utils/log"
 )
 
@@ -155,18 +154,14 @@ func (c *createEvidenceBase) uploadEvidence(evidencePayload []byte, repoPath str
 	}
 
 	evidenceDetails := evidenceService.EvidenceDetails{
-		SubjectUri:  repoPath,
+		SubjectUri: repoPath,
+		// evidencePayload may contain not only a DSSE envelop.
 		DSSEFileRaw: evidencePayload,
 		ProviderId:  c.providerId,
 	}
 	clientlog.Debug("Uploading evidence for subject:", repoPath)
 	body, err := evidenceManager.UploadEvidence(evidenceDetails)
 	if err != nil {
-		errStr := err.Error()
-		if strings.Contains(errStr, "400") || strings.Contains(errStr, "404") {
-			clientlog.Debug("Server response error:", err.Error())
-			return errorutils.CheckErrorf("Subject '%s' is invalid or not found. Please ensure the subject exists and follows the correct format: <repo>/<path>/<name> or <repo>/<name>", repoPath)
-		}
 		return err
 	}
 
diff --git a/evidence/create/create_custom.go b/evidence/create/create_custom.go
@@ -4,6 +4,7 @@ import (
 	"encoding/json"
 	clientLog "github.com/jfrog/jfrog-client-go/utils/log"
 	"github.com/sigstore/sigstore-go/pkg/bundle"
+	"regexp"
 	"strings"
 
 	"github.com/jfrog/jfrog-cli-artifactory/evidence"
@@ -61,11 +62,13 @@ func (c *createEvidenceCustom) Run() error {
 		return err
 	}
 
+	err = validateSubject(c.subjectRepoPath)
+	if err != nil {
+		return err
+	}
 	err = c.uploadEvidence(evidencePayload, c.subjectRepoPath)
 	if err != nil {
-		if strings.Contains(err.Error(), "evidence selector must be of {repository}/{path}/{name}") {
-			return errorutils.CheckErrorf("Invalid subject format: '%s'. Subject must be in format: <repo>/<path>/<name> or <repo>/<name>", c.subjectRepoPath)
-		}
+		err = handleSubjectNotFound(err, c.subjectRepoPath)
 		return err
 	}
 
@@ -84,20 +87,25 @@ func (c *createEvidenceCustom) processSigstoreBundle() ([]byte, error) {
 		if err != nil {
 			return nil, err
 		}
-		clientLog.Debug("subject extracted from sigstore bundle:", extractedSubject)
 		c.subjectRepoPath = extractedSubject
 	}
 
 	return json.Marshal(sigstoreBundle)
 }
 
 func (c *createEvidenceCustom) extractSubjectFromBundle(bundle *bundle.Bundle) (string, error) {
-	repoPath, err := sigstore.ExtractSubjectFromBundle(bundle)
+	subject, err := sigstore.ExtractSubjectFromBundle(bundle)
 	if err != nil {
 		return "", err
 	}
 
-	return repoPath, nil
+	if subject == "" {
+		return "", errorutils.CheckErrorf("Subject is not found in the sigstore bundle. Please ensure the bundle contains a valid subject.")
+	} else {
+		clientLog.Info("Subject '%s' is resolved from sigstore bundle:", subject)
+	}
+
+	return subject, nil
 }
 
 func (c *createEvidenceCustom) createDSSEEnvelope() ([]byte, error) {
@@ -108,3 +116,20 @@ func (c *createEvidenceCustom) createDSSEEnvelope() ([]byte, error) {
 
 	return envelope, nil
 }
+
+func validateSubject(subject string) error {
+	// Pattern: must have at least one slash with non-empty sections
+	if matched, _ := regexp.MatchString(`^[^/]+(/[^/]+)+$`, subject); !matched {
+		return errorutils.CheckErrorf("Subject '%s' is invalid. Subject must be in format: <repo>/<path>/<name> or <repo>/<name>", subject)
+	}
+	return nil
+}
+
+func handleSubjectNotFound(err error, subject string) error {
+	errStr := err.Error()
+	if strings.Contains(errStr, "404 Not Found") {
+		clientLog.Debug("Server response error:", err.Error())
+		return errorutils.CheckErrorf("Subject '%s' is not found. Please ensure the subject exists.", subject)
+	}
+	return err
+}
diff --git a/evidence/sigstore/bundle_parser.go b/evidence/sigstore/bundle_parser.go
@@ -27,7 +27,7 @@ func GetDSSEEnvelope(b *bundle.Bundle) (*protodsse.Envelope, error) {
 	switch c := content.(type) {
 	case *protobundle.Bundle_DsseEnvelope:
 		if c.DsseEnvelope == nil {
-			return nil, errorutils.CheckErrorf("DSSE envelope is nil")
+			return nil, errorutils.CheckErrorf("DSSE envelope is empty")
 		}
 		return c.DsseEnvelope, nil
 	default:
diff --git a/evidence/sigstore/bundle_parser_test.go b/evidence/sigstore/bundle_parser_test.go
@@ -8,88 +8,20 @@ import (
 	"github.com/stretchr/testify/assert"
 )
 
-func TestParseBundleV02(t *testing.T) {
-	// Create test bundle JSON with v0.2 format
-	bundleJSON := `{
-		"mediaType": "application/vnd.dev.sigstore.bundle+json;version=0.2",
-		"verificationMaterial": {
-			"certificate": {
-				"rawBytes": "dGVzdC1jZXJ0"
-			}
-		},
-		"dsseEnvelope": {
-			"payload": "dGVzdCBwYXlsb2Fk",
-			"payloadType": "application/vnd.in-toto+json",
-			"signatures": [
-				{
-					"sig": "dGVzdC1zaWduYXR1cmU=",
-					"keyid": "test-key-id"
-				}
-			]
-		}
-	}`
+func TestParseBundleRealFile(t *testing.T) {
+	bundlePath := filepath.Join("testdata", "sample-bundle.json")
 
-	// Write to temp file
-	tmpDir := t.TempDir()
-	bundlePath := filepath.Join(tmpDir, "test-bundle.json")
-	err := os.WriteFile(bundlePath, []byte(bundleJSON), 0644)
-	assert.NoError(t, err)
-
-	// Test parsing
 	bundle, err := ParseBundle(bundlePath)
 	assert.NoError(t, err)
 	assert.NotNil(t, bundle)
 
-	// Test DSSE extraction
 	envelope, err := GetDSSEEnvelope(bundle)
 	assert.NoError(t, err)
 	assert.NotNil(t, envelope)
 	assert.Equal(t, "application/vnd.in-toto+json", envelope.PayloadType)
 	assert.Len(t, envelope.Signatures, 1)
 }
 
-func TestParseBundleV01(t *testing.T) {
-	// Create test bundle JSON with v0.1 format (backward compatibility)
-	bundleJSON := `{
-		"mediaType": "application/vnd.dev.sigstore.bundle+json;version=0.1",
-		"verificationMaterial": {
-			"x509CertificateChain": {
-				"certificates": [
-					{
-						"rawBytes": "dGVzdC1jZXJ0"
-					}
-				]
-			}
-		},
-		"dsseEnvelope": {
-			"payload": "dGVzdCBwYXlsb2Fk",
-			"payloadType": "application/vnd.in-toto+json",
-			"signatures": [
-				{
-					"sig": "bGVnYWN5LXNpZ25hdHVyZQ==",
-					"keyid": ""
-				}
-			]
-		}
-	}`
-
-	// Write to temp file
-	tmpDir := t.TempDir()
-	bundlePath := filepath.Join(tmpDir, "test-bundle-v01.json")
-	err := os.WriteFile(bundlePath, []byte(bundleJSON), 0644)
-	assert.NoError(t, err)
-
-	// Test parsing
-	bundle, err := ParseBundle(bundlePath)
-	assert.NoError(t, err)
-	assert.NotNil(t, bundle)
-
-	// Test DSSE extraction
-	envelope, err := GetDSSEEnvelope(bundle)
-	assert.NoError(t, err)
-	assert.NotNil(t, envelope)
-}
-
 func TestParseBundleInvalidFile(t *testing.T) {
 	_, err := ParseBundle("/non/existent/file.json")
 	assert.Error(t, err)
diff --git a/evidence/sigstore/subject_extractor.go b/evidence/sigstore/subject_extractor.go
@@ -40,34 +40,5 @@ func extractRepoPathFromStatement(statement map[string]interface{}) string {
 			}
 		}
 	}
-
-	if predicate, ok := statement["predicate"].(map[string]interface{}); ok {
-		if artifact, ok := predicate["artifact"].(map[string]interface{}); ok {
-			if path, ok := artifact["path"].(string); ok && path != "" {
-				return path
-			}
-			if uri, ok := artifact["uri"].(string); ok && uri != "" {
-				return uri
-			}
-		}
-
-		if subject, ok := predicate["subject"].(map[string]interface{}); ok {
-			if path, ok := subject["path"].(string); ok && path != "" {
-				return path
-			}
-			if uri, ok := subject["uri"].(string); ok && uri != "" {
-				return uri
-			}
-		}
-
-		if materials, ok := predicate["materials"].([]interface{}); ok && len(materials) > 0 {
-			if material, ok := materials[0].(map[string]interface{}); ok {
-				if uri, ok := material["uri"].(string); ok && uri != "" {
-					return uri
-				}
-			}
-		}
-	}
-
 	return ""
 }
diff --git a/evidence/sigstore/subject_extractor_test.go b/evidence/sigstore/subject_extractor_test.go
diff --git a/evidence/sigstore/testdata/sample-bundle.json b/evidence/sigstore/testdata/sample-bundle.json

Original file line number	Diff line number	Diff line change
`@@ -22,7 +22,7 @@ func NewEvidenceBuildCommand(ctx *components.Context, execute execCommandFunc) E`
`22`	`22`
`23`	`23`	`func (ebc evidenceBuildCommand) CreateEvidence(ctx components.Context, serverDetails *config.ServerDetails) error {`
`24`	`24`	`if ebc.ctx.GetStringFlagValue(sigstoreBundle) != "" {`
`25`		`- return errorutils.CheckErrorf("--sigstore-bundle is currently not supported for build evidence. This feature may be supported in future releases.")`
	`25`	`+ return errorutils.CheckErrorf("--%s is currently not supported for build evidence.", sigstoreBundle)`
`26`	`26`	`}`
`27`	`27`
`28`	`28`	`err := ebc.validateEvidenceBuildContext(ctx)`
Original file line number	Diff line number	Diff line change
`@@ -26,7 +26,7 @@ func TestEvidenceBuildCommand_CreateEvidence_SigstoreBundle(t *testing.T) {`
`26`	`26`	`setDefaultValue(buildNumber, "123"),`
`27`	`27`	`},`
`28`	`28`	`expectError: true,`
`29`		`- errorContains: "--sigstore-bundle is currently not supported for build evidence. This feature may be supported in future releases.",`
	`29`	`+ errorContains: "--sigstore-bundle is currently not supported for build evidence.",`
`30`	`30`	`},`
`31`	`31`	`{`
`32`	`32`	`name: "Valid_Without_SigstoreBundle",`
Original file line number	Diff line number	Diff line change
`@@ -120,7 +120,7 @@ func validateCreateEvidenceCommonContext(ctx *components.Context) error {`
`120`	`120`	`}`
`121`	`121`
`122`	`122`	`if ctx.IsFlagSet(sigstoreBundle) && assertValueProvided(ctx, sigstoreBundle) == nil {`
`123`		`- if err := validateSigstoreBundleConflicts(ctx); err != nil {`
	`123`	`+ if err := validateSigstoreBundleArgsConflicts(ctx); err != nil {`
`124`	`124`	`return err`
`125`	`125`	`}`
`126`	`126`	`return nil`
`@@ -144,24 +144,24 @@ func validateCreateEvidenceCommonContext(ctx *components.Context) error {`
`144`	`144`	`return nil`
`145`	`145`	`}`
`146`	`146`
`147`		`-func validateSigstoreBundleConflicts(ctx *components.Context) error {`
	`147`	`+func validateSigstoreBundleArgsConflicts(ctx *components.Context) error {`
`148`	`148`	`var conflictingParams []string`
`149`	`149`
`150`	`150`	`if ctx.IsFlagSet(key) && ctx.GetStringFlagValue(key) != "" {`
`151`		`- conflictingParams = append(conflictingParams, "--key")`
	`151`	`+ conflictingParams = append(conflictingParams, "--"+key)`
`152`	`152`	`}`
`153`	`153`	`if ctx.IsFlagSet(keyAlias) && ctx.GetStringFlagValue(keyAlias) != "" {`
`154`		`- conflictingParams = append(conflictingParams, "--key-alias")`
	`154`	`+ conflictingParams = append(conflictingParams, "--"+keyAlias)`
`155`	`155`	`}`
`156`	`156`	`if ctx.IsFlagSet(predicate) && ctx.GetStringFlagValue(predicate) != "" {`
`157`		`- conflictingParams = append(conflictingParams, "--predicate")`
	`157`	`+ conflictingParams = append(conflictingParams, "--"+predicate)`
`158`	`158`	`}`
`159`	`159`	`if ctx.IsFlagSet(predicateType) && ctx.GetStringFlagValue(predicateType) != "" {`
`160`		`- conflictingParams = append(conflictingParams, "--predicate-type")`
	`160`	`+ conflictingParams = append(conflictingParams, "--"+predicateType)`
`161`	`161`	`}`
`162`	`162`
`163`	`163`	`if len(conflictingParams) > 0 {`
`164`		`- return errorutils.CheckErrorf("The following parameters cannot be used with --sigstore-bundle: %s. When using --sigstore-bundle, these values are extracted from the bundle itself.", strings.Join(conflictingParams, ", "))`
	`164`	`+ return errorutils.CheckErrorf("The following parameters cannot be used with --%s: %s. These values are extracted from the bundle itself:", sigstoreBundle, strings.Join(conflictingParams, ", "))`
`165`	`165`	`}`
`166`	`166`
`167`	`167`	`return nil`
`@@ -238,7 +238,7 @@ func validateKeys(ctx *components.Context) error {`
`238`	`238`	`providedKeys := ctx.GetStringsArrFlagValue(publicKeys)`
`239`	`239`	`if signingKeyValue == "" {`
`240`	`240`	`if len(providedKeys) == 0 && !ctx.GetBoolFlagValue(useArtifactoryKeys) {`
`241`		`- return errorutils.CheckErrorf("JFROG_CLI_SIGNING_KEY env variable or --public-keys flag or --use-artifactory-publicKeys must be provided when verifying evidence")`
	`241`	`+ return errorutils.CheckErrorf("JFROG_CLI_SIGNING_KEY env variable or --%s flag or --%s must be provided when verifying evidence", publicKeys, useArtifactoryKeys)`
`242`	`242`	`}`
`243`	`243`	`return nil`
`244`	`244`	`}`
`@@ -292,7 +292,7 @@ func platformToEvidenceUrls(rtDetails *config.ServerDetails) {`
`292`	`292`
`293`	`293`	`func assertValueProvided(c *components.Context, fieldName string) error {`
`294`	`294`	`if c.GetStringFlagValue(fieldName) == "" {`
`295`		`- return errorutils.CheckErrorf("the --%s option is mandatory", fieldName)`
	`295`	`+ return errorutils.CheckErrorf("the argument --%s can not be empty", fieldName)`
`296`	`296`	`}`
`297`	`297`	`return nil`
`298`	`298`	`}`
Original file line number	Diff line number	Diff line change
`@@ -586,7 +586,7 @@ func TestValidateSigstoreBundleConflicts(t *testing.T) {`
`586`	`586`	`t.Fatal(err)`
`587`	`587`	`}`
`588`	`588`
`589`		`- err = validateSigstoreBundleConflicts(context)`
	`589`	`+ err = validateSigstoreBundleArgsConflicts(context)`
`590`	`590`
`591`	`591`	`if tt.expectError {`
`592`	`592`	`assert.Error(t, err)`
Original file line number	Diff line number	Diff line change
`@@ -21,7 +21,7 @@ func NewEvidenceCustomCommand(ctx *components.Context, execute execCommandFunc)`
`21`	`21`	`}`
`22`	`22`	`func (ecc evidenceCustomCommand) CreateEvidence(_ components.Context, serverDetails *config.ServerDetails) error {`
`23`	`23`	`if ecc.ctx.GetStringFlagValue(sigstoreBundle) != "" && ecc.ctx.GetStringFlagValue(subjectSha256) != "" {`
`24`		`- return errorutils.CheckErrorf("The parameter --subject-sha256 cannot be used with --sigstore-bundle. When using --sigstore-bundle, the subject hash is extracted from the bundle itself.")`
	`24`	`+ return errorutils.CheckErrorf("The parameter --%s cannot be used with --%s. The subject hash is extracted from the bundle itself.", subjectSha256, sigstoreBundle)`
`25`	`25`	`}`
`26`	`26`
`27`	`27`	`// Single command handles both regular evidence creation and sigstore bundles`
Original file line number	Diff line number	Diff line change
`@@ -21,7 +21,7 @@ func NewEvidenceGitHubCommand(ctx *components.Context, execute execCommandFunc)`
`21`	`21`
`22`	`22`	`func (ebc evidenceGitHubCommand) CreateEvidence(ctx components.Context, serverDetails *config.ServerDetails) error {`
`23`	`23`	`if ebc.ctx.GetStringFlagValue(sigstoreBundle) != "" {`
`24`		`- return errorutils.CheckErrorf("--sigstore-bundle is currently not supported for GitHub evidence. This feature may be supported in future releases.")`
	`24`	`+ return errorutils.CheckErrorf("--%s is currently not supported for GitHub evidence.", sigstoreBundle)`
`25`	`25`	`}`
`26`	`26`
`27`	`27`	`err := ebc.validateEvidenceBuildContext(ctx)`
Original file line number	Diff line number	Diff line change
`@@ -27,7 +27,7 @@ func TestEvidenceGitHubCommand_CreateEvidence_SigstoreBundle(t *testing.T) {`
`27`	`27`	`setDefaultValue(typeFlag, "github"),`
`28`	`28`	`},`
`29`	`29`	`expectError: true,`
`30`		`- errorContains: "--sigstore-bundle is currently not supported for GitHub evidence. This feature may be supported in future releases.",`
	`30`	`+ errorContains: "--sigstore-bundle is currently not supported for GitHub evidence.",`
`31`	`31`	`},`
`32`	`32`	`{`
`33`	`33`	`name: "Valid_Without_SigstoreBundle",`
Original file line number	Diff line number	Diff line change
`@@ -22,7 +22,7 @@ func NewEvidencePackageCommand(ctx *components.Context, execute execCommandFunc)`
`22`	`22`
`23`	`23`	`func (epc evidencePackageCommand) CreateEvidence(ctx components.Context, serverDetails *config.ServerDetails) error {`
`24`	`24`	`if epc.ctx.GetStringFlagValue(sigstoreBundle) != "" {`
`25`		`- return errorutils.CheckErrorf("--sigstore-bundle is currently not supported for package evidence. This feature may be supported in future releases.")`
	`25`	`+ return errorutils.CheckErrorf("--%s is currently not supported for package evidence.", sigstoreBundle)`
`26`	`26`	`}`
`27`	`27`
`28`	`28`	`err := epc.validateEvidencePackageContext(ctx)`
Original file line number	Diff line number	Diff line change
`@@ -27,7 +27,7 @@ func TestEvidencePackageCommand_CreateEvidence_SigstoreBundle(t *testing.T) {`
`27`	`27`	`setDefaultValue(packageRepoName, "test-repo"),`
`28`	`28`	`},`
`29`	`29`	`expectError: true,`
`30`		`- errorContains: "--sigstore-bundle is currently not supported for package evidence. This feature may be supported in future releases.",`
	`30`	`+ errorContains: "--sigstore-bundle is currently not supported for package evidence.",`
`31`	`31`	`},`
`32`	`32`	`{`
`33`	`33`	`name: "Valid_Without_SigstoreBundle",`
Original file line number	Diff line number	Diff line change
`@@ -22,7 +22,7 @@ func NewEvidenceReleaseBundleCommand(ctx *components.Context, execute execComman`
`22`	`22`
`23`	`23`	`func (erc evidenceReleaseBundleCommand) CreateEvidence(ctx components.Context, serverDetails *config.ServerDetails) error {`
`24`	`24`	`if erc.ctx.GetStringFlagValue(sigstoreBundle) != "" {`
`25`		`- return errorutils.CheckErrorf("--sigstore-bundle is currently not supported for release bundle evidence. This feature may be supported in future releases.")`
	`25`	`+ return errorutils.CheckErrorf("--%s is currently not supported for release bundle evidence.", sigstoreBundle)`
`26`	`26`	`}`
`27`	`27`
`28`	`28`	`err := erc.validateEvidenceReleaseBundleContext(ctx)`