coder · Emyrk · Mar 9, 2021 · Mar 8, 2021 · Mar 8, 2021 · Mar 8, 2021
diff --git a/coder-sdk/error.go b/coder-sdk/error.go
@@ -17,31 +17,52 @@ var ErrPermissions = xerrors.New("insufficient permissions")
 // ErrAuthentication describes the error case in which the requester has invalid authentication.
 var ErrAuthentication = xerrors.New("invalid authentication")
 
-// apiError is the expected payload format for our errors.
-type apiError struct {
-	Err apiErrorMsg `json:"error"`
+// APIError is the expected payload format for API errors.
+type APIError struct {
+	Err APIErrorMsg `json:"error"`
 }
 
-// apiErrorMsg contains the rich error information returned by API errors.
-type apiErrorMsg struct {
-	Msg string `json:"msg"`
+// APIErrorMsg contains the rich error information returned by API errors.
+type APIErrorMsg struct {
+	Msg     string          `json:"msg"`
+	Code    string          `json:"code"`
+	Details json.RawMessage `json:"details"`
 }
 
 // HTTPError represents an error from the Coder API.
 type HTTPError struct {
 	*http.Response
+	cached    *APIError
+	cachedErr error
 }
 
-func (e *HTTPError) Error() string {
-	var msg apiError
+// Payload decode the response body into the standard error structure. The `details`
+// section is stored as a raw json, and type depends on the `code` field.
+func (e *HTTPError) Payload() (*APIError, error) {
+	var msg APIError
+	if e.cached != nil || e.cachedErr != nil {
+		return e.cached, e.cachedErr
+	}
+
 	// Try to decode the payload as an error, if it fails or if there is no error message,
 	// return the response URL with the status.
-	if err := json.NewDecoder(e.Response.Body).Decode(&msg); err != nil || msg.Err.Msg == "" {
+	if err := json.NewDecoder(e.Response.Body).Decode(&msg); err != nil {
+		e.cachedErr = err
+		return nil, err
+	}
+
+	e.cached = &msg
+	return &msg, nil
+}
+
+func (e *HTTPError) Error() string {
+	apiErr, err := e.Payload()
+	if err != nil || apiErr.Err.Msg == "" {
 		return fmt.Sprintf("%s: %d %s", e.Request.URL, e.StatusCode, e.Status)
 	}
 
 	// If the payload was a in the expected error format with a message, include it.
-	return msg.Err.Msg
+	return apiErr.Err.Msg
 }
 
 func bodyError(resp *http.Response) error {

diff --git a/internal/cmd/envs.go b/internal/cmd/envs.go
@@ -290,8 +290,8 @@ func createEnvFromRepoCmd() *cobra.Command {
 		Long:   "Create a new Coder environment from a config file.",
 		Hidden: true,
 		Example: `# create a new environment from git repository template
-coder envs create-from-repo --repo-url github.com/cdr/m --branch my-branch
-coder envs create-from-repo -f coder.yaml`,
+coder envs create-from-config --repo-url github.com/cdr/m --branch my-branch
+coder envs create-from-config -f coder.yaml`,
 		RunE: func(cmd *cobra.Command, args []string) error {
 			ctx := cmd.Context()
 
@@ -355,7 +355,7 @@ coder envs create-from-repo -f coder.yaml`,
 
 			tpl, err := client.ParseTemplate(ctx, req)
 			if err != nil {
-				return xerrors.Errorf("parse environment template config: %w", err)
+				return handleAPIError(err)
 			}
 
 			provider, err := coderutil.DefaultWorkspaceProvider(ctx, client)
@@ -370,7 +370,7 @@ coder envs create-from-repo -f coder.yaml`,
 				Namespace:      provider.DefaultNamespace,
 			})
 			if err != nil {
-				return xerrors.Errorf("create environment: %w", err)
+				return handleAPIError(err)
 			}
 
 			if follow {

diff --git a/internal/cmd/errors.go b/internal/cmd/errors.go
@@ -0,0 +1,71 @@
+package cmd
+
+import (
+	"encoding/json"
+	"fmt"
+
+	"golang.org/x/xerrors"
+
+	"cdr.dev/coder-cli/coder-sdk"
+	"cdr.dev/coder-cli/pkg/clog"
+)
+
+// handleAPIError attempts to convert an api error into a more detailed clog error.
+// If it cannot, it will return the original error.
+func handleAPIError(origError error) error {
+	var httpError *coder.HTTPError
+	if !xerrors.As(origError, &httpError) {
+		return origError // Return the original
+	}
+
+	ae, err := httpError.Payload()
+	if err != nil {
+		return origError // Return the original
+	}
+
+	switch ae.Err.Code {
+	case "wac_template": // template parse errors
+		type templatePayload struct {
+			ErrorType string   `json:"error_type"`
+			Msgs      []string `json:"messages"`
+		}
+
+		var p templatePayload
+		err := json.Unmarshal(ae.Err.Details, &p)
+		if err != nil {
+			return origError
+		}
+
+		return clog.Error(p.ErrorType, p.Msgs...)
+	case "verbose":
+		type verbosePayload struct {
+			Verbose string `json:"verbose"`
+		}
+		var p verbosePayload
+		err := json.Unmarshal(ae.Err.Details, &p)
+		if err != nil {
+			return origError
+		}
+
+		return clog.Error(origError.Error(), p.Verbose)
+	case "precondition":
+		type preconditionPayload struct {
+			Error    string `json:"error"`
+			Message  string `json:"message"`
+			Solution string `json:"solution"`
+		}
+
+		var p preconditionPayload
+		err := json.Unmarshal(ae.Err.Details, &p)
+		if err != nil {
+			return origError
+		}
+
+		return clog.Error(fmt.Sprintf("Precondition Error : Status Code=%d", httpError.StatusCode),
+			p.Message,
+			clog.BlankLine,
+			clog.Tipf(p.Solution))
+	}
+
+	return origError // Return the original
+}