The translation files must be updated, the rest is good. I'll approve as soon that's fixed. 👍

After trying the current solution for a bit I found two annoying problems:

1. the error messages are not consistent, just to make an example the snippet:

   	packageManager := i.PackageManager
   	if packageManager == nil {
   		return nil, status.New(codes.InvalidArgument, tr("Invalid instance"))
   	}

   is repeated a lot in the codebase, but there are cases where the message is different:

   		return nil, errors.Errorf(tr("incorrect instance")
   		return nil, errors.Errorf(tr("unable to find an instance with ID: %d"), instanceID)

2. developers that imports the commands package directly will have the following code broken:

   detailsResp, err := board.Details(context.Background(), detailsReq)
   if err != nil {
       fmt.Println("Error getting board details:", err)
       return
   }

   even if it seems perfectly reasonable it prints an address instead of an error message, because *status.Status did not
   implement a String() method, this is not idiomatic.

PROPOSAL

To address the two problems above, while rebasing this PR on master, I'd like to try a different approach:

1. to avoid repetition of error strings we define a bunch of common errors objects in commands/errors.go, something like:

   type InvalidInstanceError struct{}
   
   func (e *InvalidInstanceError) Error() string {
          return tr("Invalid instance")
   }

2. to make life easier for developers importing the commands package I'll try to:

   • set back the return type to error instead of *status.Status.
   • define a CommandError interface:

     type CommandError interface {
            ToRPCStatus() *status.Status
     }

   • implement the CommandError interface on all errors returned from the commands public API, in this case the InvalidInstanceError show above will become:

     type InvalidInstanceError struct{}
     
     func (e *InvalidInstanceError) Error() string {
            return tr("Invalid instance")
     }
     func (e *InvalidInstanceError) ToRPCStatus() *status.Status {
            return status.New(codes.InvalidArgument, e.Error())
     }

   • the wrappers in deamon.go will use an helper function to convert the error in the correct status.Status:

     func convertError(err error) error {
            if rpcErr, ok := err.(CommandError); ok {
                    return rpcErr.ToRPCStatus().Err()
             }
            return err
     }

Yes, I 100% agree with this new design. I think it also make it easier to handle errors internally and recover them gracefully.
Let's go! 🐎