// Please re-sort this list alphabetically if you change it!

return []*clibase.Cmd{

r.dotfiles(),

r.login(),

r.logout(),

r.netcheck(),

r.portForward(),

r.publickey(),

r.resetPassword(),

r.state(),

r.templates(),

r.tokens(),

r.users(),

r.version(defaultVersionInfo),

// Workspace Commands

r.configSSH(),

r.create(),

r.deleteWorkspace(),

r.list(),

r.ping(),

r.rename(),

r.schedules(),

r.show(),

r.speedtest(),

r.ssh(),

r.start(),

r.stop(),

r.update(),

r.restart(),

r.stat(),

// Hidden

r.gitssh(),

r.vscodeSSH(),

r.workspaceAgent(),

r.expCmd(),

}

all := append(r.Core(), r.Server(func(_ context.Context, o *coderd.Options) (*coderd.API, io.Closer, error) {

api := coderd.New(o)

return api, api, nil

}))

return all

rand.Seed(time.Now().UnixMicro())

cmd, err := r.Command(subcommands)

if err != nil {

panic(err)

}

err = cmd.Invoke().WithOS().Run()

if err != nil {

if errors.Is(err, cliui.Canceled) {

//nolint:revive

os.Exit(1)

}

f := prettyErrorFormatter{w: os.Stderr}

f.format(err)

//nolint:revive

os.Exit(1)

}

fmtLong := `Coder %s — A tool for provisioning self-hosted development environments with Terraform.

cmd := &clibase.Cmd{

Use: "coder [global-flags] <subcommand>",

Long: fmt.Sprintf(fmtLong, buildinfo.Version()) + formatExamples(

example{

Description: "Start a Coder server",

Command: "coder server",

},

example{

Description: "Get started by creating a template from an example",

Command: "coder templates init",

},

),

Handler: func(i *clibase.Invocation) error {

// fmt.Fprintf(i.Stderr, "env debug: %+v", i.Environ)

// The GIT_ASKPASS environment variable must point at

// a binary with no arguments. To prevent writing

// cross-platform scripts to invoke the Coder binary

// with a `gitaskpass` subcommand, we override the entrypoint

// to check if the command was invoked.

if gitauth.CheckCommand(i.Args, i.Environ.ToOS()) {

return r.gitAskpass().Handler(i)

}

return i.Command.HelpHandler(i)

},

}

cmd.AddSubcommands(subcommands...)

// Set default help handler for all commands.

cmd.Walk(func(c *clibase.Cmd) {

if c.HelpHandler == nil {

c.HelpHandler = helpFn()

}

})

var merr error

// Add [flags] to usage when appropriate.

cmd.Walk(func(cmd *clibase.Cmd) {

const flags = "[flags]"

if strings.Contains(cmd.Use, flags) {

merr = errors.Join(

merr,

xerrors.Errorf(

"command %q shouldn't have %q in usage since it's automatically populated",

cmd.FullUsage(),

flags,

),

)

return

}

var hasFlag bool

for _, opt := range cmd.Options {

if opt.Flag != "" {

hasFlag = true

break

}

}

if !hasFlag {

return

}

// We insert [flags] between the command's name and its arguments.

tokens := strings.SplitN(cmd.Use, " ", 2)

if len(tokens) == 1 {

cmd.Use = fmt.Sprintf("%s %s", tokens[0], flags)

return

}

cmd.Use = fmt.Sprintf("%s %s %s", tokens[0], flags, tokens[1])

})

// Add alises when appropriate.

cmd.Walk(func(cmd *clibase.Cmd) {

// TODO: we should really be consistent about naming.

if cmd.Name() == "delete" || cmd.Name() == "remove" {

if slices.Contains(cmd.Aliases, "rm") {

merr = errors.Join(

merr,

xerrors.Errorf("command %q shouldn't have alias %q since it's added automatically", cmd.FullName(), "rm"),

)

return

}

cmd.Aliases = append(cmd.Aliases, "rm")

}

})

// Sanity-check command options.

cmd.Walk(func(cmd *clibase.Cmd) {

for _, opt := range cmd.Options {

// Verify that every option is configurable.

if opt.Flag == "" && opt.Env == "" {

if cmd.Name() == "server" {

// The server command is funky and has YAML-only options, e.g.

// support links.

return

}

merr = errors.Join(

merr,

xerrors.Errorf("option %q in %q should have a flag or env", opt.Name, cmd.FullName()),

)

}

}

})

if merr != nil {

return nil, merr

}

var debugOptions bool

// Add a wrapper to every command to enable debugging options.

cmd.Walk(func(cmd *clibase.Cmd) {

h := cmd.Handler

if h == nil {

// We should never have a nil handler, but if we do, do not

// wrap it. Wrapping it just hides a nil pointer dereference.

// If a nil handler exists, this is a developer bug. If no handler

// is required for a command such as command grouping (e.g. `users'

// and 'groups'), then the handler should be set to the helper

// function.

// func(inv *clibase.Invocation) error {

// return inv.Command.HelpHandler(inv)

// }

return

}

cmd.Handler = func(i *clibase.Invocation) error {

if !debugOptions {

return h(i)

}

tw := tabwriter.NewWriter(i.Stdout, 0, 0, 4, ' ', 0)

_, _ = fmt.Fprintf(tw, "Option\tValue Source\n")

for _, opt := range cmd.Options {

_, _ = fmt.Fprintf(tw, "%q\t%v\n", opt.Name, opt.ValueSource)

}

tw.Flush()

return nil

}

})

if r.agentURL == nil {

r.agentURL = new(url.URL)

}

if r.clientURL == nil {

r.clientURL = new(url.URL)

}

globalGroup := &clibase.Group{

Name: "Global",

Description: `Global options are applied to all commands. They can be set using environment variables or flags.`,

}

cmd.Options = clibase.OptionSet{

{

Flag: varURL,

Env: envURL,

Description: "URL to a deployment.",

Value: clibase.URLOf(r.clientURL),

Group: globalGroup,

},

{

Flag: "debug-options",

Description: "Print all options, how they're set, then exit.",

Value: clibase.BoolOf(&debugOptions),

Group: globalGroup,

},

{

Flag: varToken,

Env: envSessionToken,

Description: fmt.Sprintf("Specify an authentication token. For security reasons setting %s is preferred.", envSessionToken),

Value: clibase.StringOf(&r.token),

Group: globalGroup,

},

{

Flag: varAgentToken,

Env: envAgentToken,

Description: "An agent authentication token.",

Value: clibase.StringOf(&r.agentToken),

Hidden: true,

Group: globalGroup,

},

{

Flag: varAgentURL,

Env: "CODER_AGENT_URL",

Description: "URL for an agent to access your deployment.",

Value: clibase.URLOf(r.agentURL),

Hidden: true,

Group: globalGroup,

},

{

Flag: varNoVersionCheck,

Env: envNoVersionCheck,

Description: "Suppress warning when client and server versions do not match.",

Value: clibase.BoolOf(&r.noVersionCheck),

Group: globalGroup,

},

{

Flag: varNoFeatureWarning,

Env: envNoFeatureWarning,

Description: "Suppress warnings about unlicensed features.",

Value: clibase.BoolOf(&r.noFeatureWarning),

Group: globalGroup,

},

{

Flag: varHeader,

Env: "CODER_HEADER",

Description: "Additional HTTP headers added to all requests. Provide as " + `key=value` + ". Can be specified multiple times.",

Value: clibase.StringArrayOf(&r.header),

Group: globalGroup,

},

{

Flag: varNoOpen,

Env: "CODER_NO_OPEN",

Description: "Suppress opening the browser after logging in.",

Value: clibase.BoolOf(&r.noOpen),

Hidden: true,

Group: globalGroup,

},

{

Flag: varForceTty,

Env: "CODER_FORCE_TTY",

Hidden: true,

Description: "Force the use of a TTY.",

Value: clibase.BoolOf(&r.forceTTY),

Group: globalGroup,

},

{

Flag: varVerbose,

FlagShorthand: "v",

Env: "CODER_VERBOSE",

Description: "Enable verbose output.",

Value: clibase.BoolOf(&r.verbose),

Group: globalGroup,

},

{

Flag: varDisableDirect,

Env: "CODER_DISABLE_DIRECT_CONNECTIONS",

Description: "Disable direct (P2P) connections to workspaces.",

Value: clibase.BoolOf(&r.disableDirect),

Group: globalGroup,

},

{

Flag: "debug-http",

Description: "Debug codersdk HTTP requests.",

Value: clibase.BoolOf(&r.debugHTTP),

Group: globalGroup,

Hidden: true,

},

{

Flag: config.FlagName,

Env: "CODER_CONFIG_DIR",

Description: "Path to the global `coder` config directory.",

Default: config.DefaultDir(),

Value: clibase.StringOf(&r.globalConfig),

Group: globalGroup,

},

}

err := cmd.PrepareAll()

if err != nil {

return nil, err

}

return cmd, nil

clientURL *url.URL

token string

globalConfig string

header []string

agentToken string

agentURL *url.URL

forceTTY bool

noOpen bool

verbose bool

disableDirect bool

debugHTTP bool

noVersionCheck bool

noFeatureWarning bool

transport, ok := client.HTTPClient.Transport.(*headerTransport)

if !ok {

transport = &headerTransport{

transport: client.HTTPClient.Transport,

header: http.Header{},

}

client.HTTPClient.Transport = transport

}

var topts []telemetry.CLIOption

for _, opt := range inv.Command.FullOptions() {

if opt.ValueSource == clibase.ValueSourceNone || opt.ValueSource == clibase.ValueSourceDefault {

continue

}

topts = append(topts, telemetry.CLIOption{

Name: opt.Name,

ValueSource: string(opt.ValueSource),

})

}

ti := telemetry.CLIInvocation{

Command: inv.Command.FullName(),

Options: topts,

InvokedAt: time.Now(),

}

byt, err := json.Marshal(ti)

if err != nil {

// Should be impossible

panic(err)

}

// Per https://stackoverflow.com/questions/686217/maximum-on-http-header-values,

// we don't want to send headers that are too long.

s := base64.StdEncoding.EncodeToString(byt)

if len(s) > 4096 {

return

}

transport.header.Add(codersdk.CLITelemetryHeader, s)

if client == nil {

panic("client is nil")

}

if r == nil {

panic("root is nil")

}

return func(next clibase.HandlerFunc) clibase.HandlerFunc {

return func(inv *clibase.Invocation) error {

conf := r.createConfig()

var err error

if r.clientURL == nil || r.clientURL.String() == "" {

rawURL, err := conf.URL().Read()

// If the configuration files are absent, the user is logged out

if os.IsNotExist(err) {

return (errUnauthenticated)

}

if err != nil {

return err

}

r.clientURL, err = url.Parse(strings.TrimSpace(rawURL))

if err != nil {

return err

}

}

if r.token == "" {

r.token, err = conf.Session().Read()

// If the configuration files are absent, the user is logged out

if os.IsNotExist(err) {

return (errUnauthenticated)

}

if err != nil {

return err

}

}

err = r.setClient(

client, r.clientURL,

)

if err != nil {

return err

}

addTelemetryHeader(client, inv)

client.SetSessionToken(r.token)

if r.debugHTTP {

client.PlainLogger = os.Stderr

client.SetLogBodies(true)

}

client.DisableDirectConnections = r.disableDirect

// We send these requests in parallel to minimize latency.

var (

versionErr = make(chan error)

warningErr = make(chan error)

)

go func() {

versionErr <- r.checkVersions(inv, client)

close(versionErr)

}()

go func() {

warningErr <- r.checkWarnings(inv, client)

close(warningErr)

}()

if err = <-versionErr; err != nil {

// Just log the error here. We never want to fail a command

// due to a pre-run.

_, _ = fmt.Fprintf(inv.Stderr,

cliui.DefaultStyles.Warn.Render("check versions error: %s"), err)

_, _ = fmt.Fprintln(inv.Stderr)

}

if err = <-warningErr; err != nil {

// Same as above

_, _ = fmt.Fprintf(inv.Stderr,

cliui.DefaultStyles.Warn.Render("check entitlement warnings error: %s"), err)

_, _ = fmt.Fprintln(inv.Stderr)

}

return next(inv)

}

}

transport := &headerTransport{

transport: http.DefaultTransport,

header: http.Header{},

}

for _, header := range r.header {

parts := strings.SplitN(header, "=", 2)

if len(parts) < 2 {

return xerrors.Errorf("split header %q had less than two parts", header)

}

transport.header.Add(parts[0], parts[1])

}

client.URL = serverURL

client.HTTPClient = &http.Client{

Transport: transport,

}

return nil

var client codersdk.Client

err := r.setClient(&client, serverURL)

return &client, err

client := agentsdk.New(r.agentURL)

client.SetSessionToken(r.agentToken)

return client, nil

orgs, err := client.OrganizationsByUser(inv.Context(), codersdk.Me)

if err != nil {

return codersdk.Organization{}, nil

}

// For now, we won't use the config to set this.

// Eventually, we will support changing using "coder switch <org>"

return orgs[0], nil

parts := strings.Split(identifier, "/")

switch len(parts) {

case 1:

owner = codersdk.Me

workspaceName = parts[0]

case 2:

owner = parts[0]

workspaceName = parts[1]

default:

return "", "", xerrors.Errorf("invalid workspace name: %q", identifier)

}

return owner, workspaceName, nil

owner, name, err := splitNamedWorkspace(identifier)

if err != nil {

return codersdk.Workspace{}, err

}

return client.WorkspaceByOwnerAndName(ctx, owner, name, codersdk.WorkspaceOptions{})

// If the `--force-tty` command is available, and set,

// assume we're in a tty. This is primarily for cases on Windows

// where we may not be able to reliably detect this automatically (ie, tests)

forceTty, err := inv.ParsedFlags().GetBool(varForceTty)

if forceTty && err == nil {

return true

}

file, ok := inv.Stdin.(*os.File)

if !ok {

return false

}

return isatty.IsTerminal(file.Fd())

// If the `--force-tty` command is available, and set,

// assume we're in a tty. This is primarily for cases on Windows

// where we may not be able to reliably detect this automatically (ie, tests)

forceTty, err := inv.ParsedFlags().GetBool(varForceTty)

if forceTty && err == nil {

return true

}

file, ok := writer.(*os.File)

if !ok {

return false

}

return isatty.IsTerminal(file.Fd())

var sb strings.Builder

padStyle := cliui.DefaultStyles.Wrap.Copy().PaddingLeft(4)

for i, e := range examples {

if len(e.Description) > 0 {

wordwrap.WrapString(e.Description, 80)

_, _ = sb.WriteString(

" - " + padStyle.Render(e.Description + ":")[4:] + "\n\n ",

)

}

// We add 1 space here because `cliui.DefaultStyles.Code` adds an extra

// space. This makes the code block align at an even 2 or 6

// spaces for symmetry.

_, _ = sb.WriteString(" " + cliui.DefaultStyles.Code.Render(fmt.Sprintf("$ %s", e.Command)))

if i < len(examples)-1 {

_, _ = sb.WriteString("\n\n")

}

}

return sb.String()

if r.noVersionCheck {

return nil

}

ctx, cancel := context.WithTimeout(i.Context(), 10*time.Second)

defer cancel()

clientVersion := buildinfo.Version()

info, err := client.BuildInfo(ctx)

// Avoid printing errors that are connection-related.

if isConnectionError(err) {

return nil

}

if err != nil {

return xerrors.Errorf("build info: %w", err)

}

fmtWarningText := `version mismatch: client %s, server %s

// Our installation script doesn't work on Windows, so instead we direct the user

// to the GitHub release page to download the latest installer.

if runtime.GOOS == "windows" {

fmtWarningText += `download the server version from: https://github.com/coder/coder/releases/v%s`

} else {

fmtWarningText += `download the server version with: 'curl -L https://coder.com/install.sh | sh -s -- --version %s'`

}

if !buildinfo.VersionsMatch(clientVersion, info.Version) {

warn := cliui.DefaultStyles.Warn.Copy().Align(lipgloss.Left)

_, _ = fmt.Fprintf(i.Stderr, warn.Render(fmtWarningText), clientVersion, info.Version, strings.TrimPrefix(info.CanonicalVersion(), "v"))

_, _ = fmt.Fprintln(i.Stderr)

}

return nil

if r.noFeatureWarning {

return nil

}

ctx, cancel := context.WithTimeout(i.Context(), 10*time.Second)

defer cancel()

entitlements, err := client.Entitlements(ctx)

if err == nil {

for _, w := range entitlements.Warnings {

_, _ = fmt.Fprintln(i.Stderr, cliui.DefaultStyles.Warn.Render(w))

}

}

return nil

for k, v := range h.header {

for _, vv := range v {

req.Header.Add(k, vv)

}

}

return h.transport.RoundTrip(req)

if runtime.GOOS == "windows" {

// free up the goroutine since it'll be permanently blocked anyways

return

}

listenSignals := []os.Signal{syscall.SIGTRAP}

if os.Getenv("GOTRACEBACK") != "crash" {

listenSignals = append(listenSignals, syscall.SIGQUIT)

}

sigs := make(chan os.Signal, 1)

signal.Notify(sigs, listenSignals...)

defer signal.Stop(sigs)

for {

sigStr := ""

select {

case <-ctx.Done():

return

case sig := <-sigs:

switch sig {

case syscall.SIGQUIT:

sigStr = "SIGQUIT"

case syscall.SIGTRAP:

sigStr = "SIGTRAP"

}

}

// Start with a 1MB buffer and keep doubling it until we can fit the

// entire stacktrace, stopping early once we reach 64MB.

buf := make([]byte, 1_000_000)

stacklen := 0

for {

stacklen = runtime.Stack(buf, true)

if stacklen < len(buf) {

break

}

if 2*len(buf) > 64_000_000 {

// Write a message to the end of the buffer saying that it was

// truncated.

const truncatedMsg = "\n\n\nstack trace truncated due to size\n"

copy(buf[len(buf)-len(truncatedMsg):], truncatedMsg)

break

}

buf = make([]byte, 2*len(buf))

}

_, _ = fmt.Fprintf(os.Stderr, "%s:\n%s\n", sigStr, buf[:stacklen])

// Write to a well-known file.

dir, err := os.UserHomeDir()

if err != nil {

dir = os.TempDir()

}

fpath := filepath.Join(dir, fmt.Sprintf("coder-agent-%s.dump", time.Now().Format("2006-01-02T15:04:05.000Z")))

_, _ = fmt.Fprintf(os.Stderr, "writing dump to %q\n", fpath)

f, err := os.Create(fpath)

if err != nil {

_, _ = fmt.Fprintf(os.Stderr, "failed to open dump file: %v\n", err.Error())

goto done

}

_, err = f.Write(buf[:stacklen])

_ = f.Close()

if err != nil {

_, _ = fmt.Fprintf(os.Stderr, "failed to write dump file: %v\n", err.Error())

goto done

}

done:

if sigStr == "SIGQUIT" {

//nolint:revive

os.Exit(1)

}

}

var (

// E.g. no such host

dnsErr *net.DNSError

// Eg. connection refused

opErr *net.OpError

)

return xerrors.As(err, &dnsErr) || xerrors.As(err, &opErr)

errTail := errors.Unwrap(err)

//nolint:errorlint

if _, ok := err.(*clibase.RunCommandError); ok && errTail != nil {

// Avoid extra nesting.

p.format(errTail)

return

}

var headErr string

if errTail != nil {

headErr = strings.TrimSuffix(err.Error(), ": "+errTail.Error())

} else {

headErr = err.Error()

}

var msg string

var sdkError *codersdk.Error

if errors.As(err, &sdkError) {

// We don't want to repeat the same error message twice, so we

// only show the SDK error on the top of the stack.

msg = sdkError.Message

if sdkError.Helper != "" {

msg = msg + "\n" + sdkError.Helper

}

// The SDK error is usually good enough, and we don't want to overwhelm

// the user with output.

errTail = nil

} else {

msg = headErr

}

headStyle := lipgloss.NewStyle().Foreground(lipgloss.Color("#D16644"))

p.printf(

headStyle,

"%s",

msg,

)

tailStyle := headStyle.Copy().Foreground(lipgloss.Color("#969696"))

if errTail != nil {

p.printf(headStyle, ": ")

// Grey out the less important, deep errors.

p.printf(tailStyle, "%s", errTail.Error())

}

p.printf(tailStyle, "\n")

s := style.Render(fmt.Sprintf(format, a...))

_, _ = p.w.Write(

[]byte(

s,

),

)