coder · cmoog · Oct 21, 2020 · Oct 21, 2020 · coadler · Oct 21, 2020
diff --git a/cmd/coder/main.go b/cmd/coder/main.go
@@ -9,10 +9,9 @@ import (
 	"os"
 	"runtime"
 
+	"cdr.dev/coder-cli/internal/clog"
 	"cdr.dev/coder-cli/internal/cmd"
 	"cdr.dev/coder-cli/internal/x/xterminal"
-
-	"go.coder.com/flog"
 )
 
 // Using a global for the version so it can be set at build time using ldflags.
@@ -31,7 +30,8 @@ func main() {
 
 	stdoutState, err := xterminal.MakeOutputRaw(os.Stdout.Fd())
 	if err != nil {
-		flog.Fatal("set output to raw: %s", err)
+		clog.Log(clog.Fatal(fmt.Sprintf("set output to raw: %s", err)))
+		os.Exit(1)
 	}
 	defer func() {
 		// Best effort. Would result in broken terminal on window but nothing we can do about it.
@@ -42,6 +42,7 @@ func main() {
 	app.Version = fmt.Sprintf("%s %s %s/%s", version, runtime.Version(), runtime.GOOS, runtime.GOARCH)
 
 	if err := app.ExecuteContext(ctx); err != nil {
-		flog.Fatal("%v", err)
+		clog.Log(err)
+		os.Exit(1)
 	}
 }
diff --git a/coder-sdk/error.go b/coder-sdk/error.go
@@ -12,8 +12,8 @@ import (
 // ErrNotFound describes an error case in which the requested resource could not be found
 var ErrNotFound = xerrors.Errorf("resource not found")
 
-// apiError is the expected payload format for our errors.
-type apiError struct {
+// APIError is the expected payload format for our errors.
+type APIError struct {
 	Err struct {
 		Msg string `json:"msg"`
 	} `json:"error"`
@@ -30,15 +30,15 @@ func (e *HTTPError) Error() string {
 		return fmt.Sprintf("dump response: %+v", err)
 	}
 
-	var msg apiError
+	var msg APIError
 	// Try to decode the payload as an error, if it fails or if there is no error message,
 	// return the response URL with the dump.
 	if err := json.NewDecoder(e.Response.Body).Decode(&msg); err != nil || msg.Err.Msg == "" {
 		return fmt.Sprintf("%s\n%s", e.Response.Request.URL, dump)
 	}
 
 	// If the payload was a in the expected error format with a message, include it.
-	return fmt.Sprintf("%s\n%s%s", e.Response.Request.URL, dump, msg.Err.Msg)
+	return msg.Err.Msg
 }
 
 func bodyError(resp *http.Response) error {

diff --git a/go.mod b/go.mod
@@ -16,7 +16,6 @@ require (
 	github.com/rjeczalik/notify v0.9.2
 	github.com/spf13/cobra v1.0.0
 	github.com/stretchr/testify v1.6.1
-	go.coder.com/flog v0.0.0-20190906214207-47dd47ea0512
 	golang.org/x/crypto v0.0.0-20200422194213-44a606286825
 	golang.org/x/sync v0.0.0-20200317015054-43a5402ce75a
 	golang.org/x/sys v0.0.0-20201018230417-eeed37f84f13

diff --git a/internal/activity/pusher.go b/internal/activity/pusher.go
@@ -2,13 +2,13 @@ package activity
 
 import (
 	"context"
+	"fmt"
 	"time"
 
 	"golang.org/x/time/rate"
 
 	"cdr.dev/coder-cli/coder-sdk"
-
-	"go.coder.com/flog"
+	"cdr.dev/coder-cli/internal/clog"
 )
 
 const pushInterval = time.Minute
@@ -42,6 +42,6 @@ func (p *Pusher) Push(ctx context.Context) {
 	}
 
 	if err := p.client.PushActivity(ctx, p.source, p.envID); err != nil {
-		flog.Error("push activity: %s", err)
+		clog.Log(clog.Error(fmt.Sprintf("push activity: %s", err)))
 	}
 }
diff --git a/internal/clog/error.go b/internal/clog/error.go
@@ -0,0 +1,131 @@
+package clog
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"strings"
+
+	"github.com/fatih/color"
+	"golang.org/x/xerrors"
+)
+
+// CLIMessage provides a human-readable message for CLI errors and messages.
+type CLIMessage struct {
+	Level  string
+	Color  color.Attribute
+	Header string
+	Lines  []string
+}
+
+// CLIError wraps a CLIMessage and allows consumers to treat it as a normal error.
+type CLIError struct {
+	CLIMessage
+	error
+}
+
+// String formats the CLI message for consumption by a human.
+func (m CLIMessage) String() string {
+	var str strings.Builder
+	str.WriteString(fmt.Sprintf("%s: %s\n",
+		color.New(m.Color).Sprint(m.Level),
+		color.New(color.Bold).Sprint(m.Header)),
+	)
+	for _, line := range m.Lines {
+		str.WriteString(fmt.Sprintf("  %s %s\n", color.New(m.Color).Sprint("|"), line))
+	}
+	return str.String()
+}
+
+// Log logs the given error to stderr, defaulting to "fatal" if the error is not a CLIError.
+// If the error is a CLIError, the plain error chain is ignored and the CLIError
+// is logged on its own.
+func Log(err error) {
+	var cliErr CLIError
+	if !xerrors.As(err, &cliErr) {
+		cliErr = Fatal(err.Error())
+	}
+	fmt.Fprintln(os.Stderr, cliErr.String())
+}
+
+// LogInfo prints the given info message to stderr.
+func LogInfo(header string, lines ...string) {
+	fmt.Fprint(os.Stderr, CLIMessage{
+		Level:  "info",
+		Color:  color.FgBlue,
+		Header: header,
+		Lines:  lines,
+	}.String())
+}
+
+// LogSuccess prints the given info message to stderr.
+func LogSuccess(header string, lines ...string) {
+	fmt.Fprint(os.Stderr, CLIMessage{
+		Level:  "success",
+		Color:  color.FgGreen,
+		Header: header,
+		Lines:  lines,
+	}.String())
+}
+
+// Warn creates an error with the level "warning".
+func Warn(header string, lines ...string) CLIError {
+	return CLIError{
+		CLIMessage: CLIMessage{
+			Color:  color.FgYellow,
+			Level:  "warning",
+			Header: header,
+			Lines:  lines,
+		},
+		error: errors.New(header),
+	}
+}
+
+// Error creates an error with the level "error".
+func Error(header string, lines ...string) CLIError {
+	return CLIError{
+		CLIMessage: CLIMessage{
+			Color:  color.FgRed,
+			Level:  "error",
+			Header: header,
+			Lines:  lines,
+		},
+		error: errors.New(header),
+	}
+}
+
+// Fatal creates an error with the level "fatal".
+func Fatal(header string, lines ...string) CLIError {
+	return CLIError{
+		CLIMessage: CLIMessage{
+			Color:  color.FgRed,
+			Level:  "fatal",
+			Header: header,
+			Lines:  lines,
+		},
+		error: errors.New(header),
+	}
+}
+
+// Bold provides a convenience wrapper around color.New for brevity when logging.
+func Bold(a string) string {
+	return color.New(color.Bold).Sprint(a)
+}
+
+// Tip formats according to the given format specifier and prepends a bolded "tip: " header.
+func Tip(format string, a ...interface{}) string {
+	return fmt.Sprintf("%s %s", Bold("tip:"), fmt.Sprintf(format, a...))
+}
+
+// Hint formats according to the given format specifier and prepends a bolded "hint: " header.
+func Hint(format string, a ...interface{}) string {
+	return fmt.Sprintf("%s %s", Bold("hint:"), fmt.Sprintf(format, a...))
+}
+
+// Cause formats according to the given format specifier and prepends a bolded "cause: " header.
+func Cause(format string, a ...interface{}) string {
+	return fmt.Sprintf("%s %s", Bold("cause:"), fmt.Sprintf(format, a...))
+}
+
+// BlankLine is an empty string meant to be used in CLIMessage and CLIError construction.
+const BlankLine = ""
diff --git a/internal/cmd/auth.go b/internal/cmd/auth.go
@@ -8,10 +8,14 @@ import (
 	"golang.org/x/xerrors"
 
 	"cdr.dev/coder-cli/coder-sdk"
+	"cdr.dev/coder-cli/internal/clog"
 	"cdr.dev/coder-cli/internal/config"
 )
 
-var errNeedLogin = xerrors.New("failed to read session credentials: did you run \"coder login\"?")
+var errNeedLogin = clog.Fatal(
+	"failed to read session credentials",
+	clog.Hint(`did you run "coder login [https://coder.domain.com]"?`),
+)
 
 func newClient() (*coder.Client, error) {
 	sessionToken, err := config.Session.Read()

diff --git a/internal/cmd/ceapi.go b/internal/cmd/ceapi.go
@@ -5,6 +5,7 @@ import (
 	"fmt"
 
 	"cdr.dev/coder-cli/coder-sdk"
+	"cdr.dev/coder-cli/internal/clog"
 	"golang.org/x/xerrors"
 )
 
@@ -73,10 +74,12 @@ func findEnv(ctx context.Context, client *coder.Client, envName, userEmail strin
 		found = append(found, env.Name)
 	}
 
-	return nil, notFoundButDidFind{
-		needle:   envName,
-		haystack: found,
-	}
+	return nil, clog.Fatal(
+		"failed to find environment",
+		fmt.Sprintf("environment %q not found in %q", envName, found),
+		clog.BlankLine,
+		clog.Tip("run \"coder envs ls\" to view your environments"),
+	)
 }
 
 type notFoundButDidFind struct {

diff --git a/internal/cmd/envs.go b/internal/cmd/envs.go
@@ -2,15 +2,16 @@ package cmd
 
 import (
 	"encoding/json"
+	"fmt"
 	"os"
+	"sync/atomic"
 
 	"cdr.dev/coder-cli/coder-sdk"
+	"cdr.dev/coder-cli/internal/clog"
 	"cdr.dev/coder-cli/internal/x/xtabwriter"
 	"github.com/spf13/cobra"
 	"golang.org/x/sync/errgroup"
 	"golang.org/x/xerrors"
-
-	"go.coder.com/flog"
 )
 
 func envsCommand() *cobra.Command {
@@ -37,7 +38,7 @@ func envsCommand() *cobra.Command {
 				return err
 			}
 			if len(envs) < 1 {
-				flog.Info("no environments found")
+				clog.LogInfo("no environments found")
 				return nil
 			}
 
@@ -92,26 +93,33 @@ coder envs --user charlie@coder.com ls -o json \
 			}
 
 			var egroup errgroup.Group
+			var fails int32
 			for _, envName := range args {
 				envName := envName
 				egroup.Go(func() error {
 					env, err := findEnv(cmd.Context(), client, envName, *user)
 					if err != nil {
-						flog.Error("failed to find environment by name \"%s\": %v", envName, err)
-						return xerrors.Errorf("find environment by name: %w", err)
+						atomic.AddInt32(&fails, 1)
+						clog.Log(err)
+						return xerrors.Errorf("find env by name: %w", err)
 					}
 
 					if err = client.StopEnvironment(cmd.Context(), env.ID); err != nil {
-						flog.Error("failed to stop environment \"%s\": %v", env.Name, err)
-						return xerrors.Errorf("stop environment: %w", err)
+						atomic.AddInt32(&fails, 1)
+						err = clog.Fatal(fmt.Sprintf("stop environment %q", env.Name),
+							clog.Cause(err.Error()), clog.BlankLine,
+							clog.Hint("current environment status is %q", env.LatestStat.ContainerStatus),
+						)
+						clog.Log(err)
+						return err
 					}
-					flog.Success("Successfully stopped environment %q", envName)
+					clog.LogSuccess(fmt.Sprintf("successfully stopped environment %q", envName))
 					return nil
 				})
 			}
 
 			if err = egroup.Wait(); err != nil {
-				return xerrors.Errorf("some stop operations failed")
+				return clog.Fatal(fmt.Sprintf("%d failure(s) emitted", fails))
 			}
 			return nil
 		},

diff --git a/internal/cmd/login.go b/internal/cmd/login.go
@@ -9,14 +9,13 @@ import (
 	"strings"
 
 	"cdr.dev/coder-cli/coder-sdk"
+	"cdr.dev/coder-cli/internal/clog"
 	"cdr.dev/coder-cli/internal/config"
 	"cdr.dev/coder-cli/internal/loginsrv"
 	"github.com/pkg/browser"
 	"github.com/spf13/cobra"
 	"golang.org/x/sync/errgroup"
 	"golang.org/x/xerrors"
-
-	"go.coder.com/flog"
 )
 
 func makeLoginCmd() *cobra.Command {
@@ -140,7 +139,7 @@ func login(cmd *cobra.Command, envURL *url.URL, urlCfg, sessionCfg config.File)
 		return xerrors.Errorf("store config: %w", err)
 	}
 
-	flog.Success("Logged in.")
+	clog.LogSuccess("logged in")
 
 	return nil
 }
diff --git a/internal/cmd/logout.go b/internal/cmd/logout.go
@@ -3,11 +3,10 @@ package cmd
 import (
 	"os"
 
+	"cdr.dev/coder-cli/internal/clog"
 	"cdr.dev/coder-cli/internal/config"
 	"github.com/spf13/cobra"
 	"golang.org/x/xerrors"
-
-	"go.coder.com/flog"
 )
 
 func makeLogoutCmd() *cobra.Command {
@@ -22,11 +21,11 @@ func logout(_ *cobra.Command, _ []string) error {
 	err := config.Session.Delete()
 	if err != nil {
 		if os.IsNotExist(err) {
-			flog.Info("no active session")
+			clog.LogInfo("no active session")
 			return nil
 		}
 		return xerrors.Errorf("delete session: %w", err)
 	}
-	flog.Success("logged out")
+	clog.LogSuccess("logged out")
 	return nil
 }