(*models.GoogleRPCStatus) is not supported by the TextConsumer,

Currently our setup is to create an image with packer and store it in gcp and promote it to hcl packer regestery for that we madePreformatted text a packer container image with HCl go tool for managing build iteration etc and all it was working fine with existing project but when I changed the project it is showing error:(cloud build) is using for this:Tracking build on HCP Packer with fingerprint “01JQ4QFZ1NV780TN4C7366N39Z”
Error: HCP: populating version failed

failed to initialize bucket “labs-windows-2022-base”: &{0 }
(*models.GoogleRPCStatus) is not supported by the TextConsumer, can be resolved
by supporting TextUnmarshaler interface
I have tried to build an image and promote it to hcl registry locally from my machine it is working fine .hcl tool is defined below

package main

import (
	"encoding/json"
	"flag"
	"fmt"
	"log"
	"os"

	packer "github.com/hashicorp/hcp-sdk-go/clients/cloud-packer-service/stable/2021-04-30/client/packer_service"
	models "github.com/hashicorp/hcp-sdk-go/clients/cloud-packer-service/stable/2021-04-30/models"
	"github.com/hashicorp/hcp-sdk-go/httpclient"
)

func main() {

	var clientId string
	var clientSecret string

	var projectId string
	var organizationId string

	flag.StringVar(&clientId, "client_id", "", "HCP Client ID")
	flag.StringVar(&clientSecret, "client_secret", "", "HCP Client Secret")

	flag.StringVar(&projectId, "project_id", "", "HCP Project ID")
	flag.StringVar(&organizationId, "organization_id", "", "HCP Organization ID")

	flag.Parse()

	// Getting Values from os.Env, if exist, as alternative.
	if clientId == "" {
		clientId = os.Getenv("HCP_CLIENT_ID")
	}

	if clientSecret == "" {
		clientSecret = os.Getenv("HCP_CLIENT_SECRET")
	}

	if projectId == "" {
		projectId = os.Getenv("HCP_PROJECT_ID")
	}

	if organizationId == "" {
		organizationId = os.Getenv("HCP_ORGANIZATION_ID")
	}

	hcp_credentials := make(map[string]string)
	hcp_credentials["clientId"] = clientId
	hcp_credentials["clientSecret"] = clientSecret
	hcp_credentials["projectId"] = projectId
	hcp_credentials["organizationId"] = organizationId
//fmt.Println(hcp_credentials)
	//---------------------------------------------------------------------------------
	resourceHandler(hcp_credentials, os.Args)
}

func credentialPrinter(clientId string, clientSecret string) {
	fmt.Println("clientId:", clientId)
	fmt.Println("clientSecret:", clientSecret)
}

func initializePackerClient() packer.ClientService {

	// Initialize SDK http client
	cl, err := httpclient.New(httpclient.Config{})
	if err != nil {
		log.Fatal(err)
	}

	// Import versioned client for each service.
	return packer.New(cl, nil)
}

func resourceHandler(hcp_credentials map[string]string, arg []string) {

	resourceType := arg[1]

	switch resourceType {
	case "bucket":
		fmt.Println("bucket")
	case "build":
		fmt.Println("build")
	case "channel":
		handleChannel(hcp_credentials, arg)
	case "iteration":
		handleIteration(hcp_credentials, arg)
	case "buckets":
		buckets_list(hcp_credentials, arg)
	}
}

/**ITERATION MANAGER*/

func handleIteration(hcp_credentials map[string]string, args []string) {

	actionVerb := args[2]

	switch actionVerb {
	case "create":
		fmt.Println("bucket")
	case "delete":
		fmt.Println("build")
	case "get":
		describeIteration(hcp_credentials, args)
	case "list":
		listIterations(hcp_credentials, args)
	case "exist":
		existIteration(hcp_credentials, args)
	case "existAsJson":
		existIterationAsJson(hcp_credentials, args)
	}
}

func describeIteration(hcp_credentials map[string]string, args []string) {

	bucketSlug := args[3]
	resourceId := args[4]

	packerClient := initializePackerClient()

	listParamsB := packer.NewPackerServiceGetIterationParams()
	listParamsB.LocationOrganizationID = hcp_credentials["organizationId"]
	listParamsB.LocationProjectID = hcp_credentials["projectId"]
	listParamsB.BucketSlug = bucketSlug
	listParamsB.IterationID = &resourceId
	respB, errB := packerClient.PackerServiceGetIteration(listParamsB, nil)

	if errB != nil {
		log.Fatal(errB)
	}

	// Debugging: Print raw API response
	fmt.Printf("Raw API Response: %+v\n", respB)

	// Check if the response contains a valid iteration
	if len(respB.Payload.Iteration.BucketSlug) > 0 {
		enc := json.NewEncoder(os.Stdout)
		enc.Encode(respB.Payload.Iteration)
	} else {
		// Handle case where iteration details are missing or empty
		if respB.Payload.Status != nil {
			fmt.Printf("Status: %v\n", respB.Payload.Status.Message)
		}
		fmt.Printf("Response: %#v\n\n", respB.Payload.Iteration)
	}
}

func listIterations(hcp_credentials map[string]string, args []string) {

	packerClient := initializePackerClient()

	listParamsB := packer.NewPackerServiceListIterationsParams()

	listParamsB.LocationOrganizationID = hcp_credentials["organizationId"]
	listParamsB.LocationProjectID = hcp_credentials["projectId"]
	listParamsB.BucketSlug = args[3]

	respB, errB := packerClient.PackerServiceListIterations(listParamsB, nil)

	if errB != nil {
		log.Fatal(errB)
	}

	// Debugging: Print raw API response
	fmt.Printf("Raw API Response: %+v\n", respB)

	if len(respB.Payload.Iterations) > 0 {
		enc := json.NewEncoder(os.Stdout)
		iterationList := respB.Payload.Iterations
		enc.Encode(iterationList)
	} else {
		fmt.Printf("Response: %#v\n\n", respB.Payload.Iterations)
	}
}
func updateIteration(hcp_credentials map[string]string, args []string) {
	fmt.Println("TODO: Not Implemented")
}

func existIteration(hcp_credentials map[string]string, args []string) {

	bucketSlug := args[3]
	fingerprintValue := args[4]

	packerClient := initializePackerClient()

	listParamsB := packer.NewPackerServiceGetIterationParams()
	listParamsB.LocationOrganizationID = hcp_credentials["organizationId"]
	listParamsB.LocationProjectID = hcp_credentials["projectId"]
	listParamsB.BucketSlug = bucketSlug
	listParamsB.Fingerprint = &fingerprintValue
	respB, errB := packerClient.PackerServiceGetIteration(listParamsB, nil)

	if errB != nil {
		log.Fatal(errB)
	}

	// Debugging: Print raw API response
	fmt.Printf("Raw API Response: %+v\n", respB)

	// Check if the iteration exists
	if len(respB.Payload.Iteration.BucketSlug) > 0 {
		fmt.Println("Name: ", respB.Payload.Iteration.BucketSlug)
		fmt.Println("Version: ", respB.Payload.Iteration.IncrementalVersion)
		fmt.Println("Update_At: ", respB.Payload.Iteration.UpdatedAt)
		fmt.Println("Builds: ", +len(respB.Payload.Iteration.Builds))
		fmt.Println("Fingerprint:", respB.Payload.Iteration.Fingerprint)
		fmt.Println("ID:", respB.Payload.Iteration.ID)
		os.Exit(0)

	} else {
		// Handle the error response
		if respB.Payload.Status != nil {
			fmt.Println("Error Status: ", respB.Payload.Status.Message)
		}
		fmt.Printf("Response: %#v\n\n", respB.Payload.Iteration)
		os.Exit(1)
	}
}

func existIterationAsJson(hcp_credentials map[string]string, args []string) {

	bucketSlug := args[3]
	fingerprintValue := args[4]

	packerClient := initializePackerClient()

	listParamsB := packer.NewPackerServiceGetIterationParams()
	listParamsB.LocationOrganizationID = hcp_credentials["organizationId"]
	listParamsB.LocationProjectID = hcp_credentials["projectId"]
	listParamsB.BucketSlug = bucketSlug
	listParamsB.Fingerprint = &fingerprintValue
	respB, errB := packerClient.PackerServiceGetIteration(listParamsB, nil)

	if errB != nil {
		mapD := map[string]string{
			"Exist": "false",
			"ErrorMessage": fmt.Sprint(errB),
		}		
		mapB, _ := json.Marshal(mapD)
		fmt.Println(string(mapB))
		os.Exit(1)
	}

	// Debugging: Print raw API response
	fmt.Printf("Raw API Response: %+v\n", respB)

	if len(respB.Payload.Iteration.Builds) > 0 {
		var iteratioExist = "false"
		var iterationStatus = "Failed"
		
		if respB.Payload.Iteration.Complete {
			iteratioExist = "true"
			iterationStatus = "Ready"
		}

		mapD := map[string]string{
			"Name": respB.Payload.Iteration.BucketSlug, 
			"Version": fmt.Sprint(respB.Payload.Iteration.IncrementalVersion),
			"Update_At": fmt.Sprint(respB.Payload.Iteration.UpdatedAt),
			"Fingerprint": respB.Payload.Iteration.Fingerprint,
			"ID": respB.Payload.Iteration.ID,
			"Exist": iteratioExist,
			"Status": iterationStatus,
		}		
		mapB, _ := json.Marshal(mapD)
		fmt.Println(string(mapB))
		os.Exit(0)

	} else {
		// Handle the case where no builds exist
		enc := json.NewEncoder(os.Stdout)
		enc.Encode(respB)
		os.Exit(1)
	}
}

/**CHANNEL MANAGER*/

func handleChannel(hcp_credentials map[string]string, args []string) {

	actionVerb := args[2]

	switch actionVerb {
	case "create":
		fmt.Println("bucket")
	case "delete":
		fmt.Println("build")
	case "iteration_update":
		channel_iteration_update(hcp_credentials, args)
	case "iteration_latest":
		channel_iteration_latest(hcp_credentials, args)
	case "list":
		listChannel(hcp_credentials, args)
	}
}

func listChannel(hcp_credentials map[string]string, args []string) {
	// Placeholder for listing channels
	fmt.Println("TODO: Not Implemented")
}

func channel_iteration_update(hcp_credentials map[string]string, args []string) {

	bucketSlug := args[3]
	resourceId := args[4]
	channelName := args[5]

	packerClient := initializePackerClient()

	listParamsB := packer.NewPackerServiceUpdateChannelParams()
	listParamsB.LocationOrganizationID = hcp_credentials["organizationId"]
	listParamsB.LocationProjectID = hcp_credentials["projectId"]
	listParamsB.BucketSlug = bucketSlug
	listParamsB.Slug = channelName

	body := &models.HashicorpCloudPackerUpdateChannelRequest{IterationID: resourceId}
	listParamsB.Body = body

	respB, errB := packerClient.PackerServiceUpdateChannel(listParamsB, nil)

	if errB != nil {
		log.Fatal(errB)
	}

	// Debugging: Print raw API response
	fmt.Printf("Raw API Response: %+v\n", respB)

	enc := json.NewEncoder(os.Stdout)
	enc.Encode(respB)
}

func channel_iteration_latest(hcp_credentials map[string]string, args []string) {

	bucketSlug := args[3]
	channelName := args[4]

	packerClient := initializePackerClient()

	listParamsB := packer.NewPackerServiceGetChannelParams()
	listParamsB.LocationOrganizationID = hcp_credentials["organizationId"]
	listParamsB.LocationProjectID = hcp_credentials["projectId"]
	listParamsB.BucketSlug = bucketSlug
	listParamsB.Slug = channelName

	respB, errB := packerClient.PackerServiceGetChannel(listParamsB, nil)

	if errB != nil {
		log.Fatal(errB)
	}
	if respB.Payload.Channel.Iteration != nil && len(respB.Payload.Channel.Iteration.Builds) > 0 {
		source_image := respB.Payload.Channel.Iteration.Builds[len(respB.Payload.Channel.Iteration.Builds)-1].Images[len(respB.Payload.Channel.Iteration.Builds)-1].ImageID
		fmt.Printf(source_image+"\n")
		os.Exit(0)
	}else{
		os.Exit(1)
	}
}

func buckets_list(hcp_credentials map[string]string, args []string) {

	packerClient := initializePackerClient()

	listParamsB := packer.NewPackerServiceListBucketsParams ()
	listParamsB.LocationOrganizationID = hcp_credentials["organizationId"]
	listParamsB.LocationProjectID = hcp_credentials["projectId"]	

	respB, errB := packerClient.PackerServiceListBuckets(listParamsB, nil)

	if errB != nil {
		log.Fatal(errB)
	}	

	if respB.Payload.Buckets != nil && len(respB.Payload.Buckets) > 0 {
		
		buckets := []string{}
		 for _, value := range respB.Payload.Buckets {
			buckets = append(buckets, value.Slug)
		 }

		 enc := json.NewEncoder(os.Stdout)
		 enc.Encode(buckets)
		 os.Exit(0)
		
	}else{
		os.Exit(1)
	}
}