2022-03-07 11:40:54 -06:00
package cli
import (
2022-03-25 10:34:45 -06:00
"context"
2022-06-17 00:54:45 -05:00
"fmt"
2023-02-01 16:04:09 +02:00
"io"
2025-04-09 09:20:47 +01:00
"net"
2022-03-28 13:31:03 -06:00
"net/http"
2022-11-08 15:02:07 +01:00
"net/http/pprof"
2022-03-07 11:40:54 -06:00
"net/url"
2022-05-02 11:36:51 -05:00
"os"
"path/filepath"
2022-06-17 11:51:46 -05:00
"runtime"
2023-03-09 10:53:00 -06:00
"strconv"
2023-08-08 22:10:28 -07:00
"strings"
2022-03-25 10:34:45 -06:00
"time"
2022-03-07 11:40:54 -06:00
2022-03-25 13:48:08 -06:00
"cloud.google.com/go/compute/metadata"
2022-03-07 11:40:54 -06:00
"golang.org/x/xerrors"
2022-06-24 10:25:01 -05:00
"gopkg.in/natefinch/lumberjack.v2"
2022-03-07 11:40:54 -06:00
2023-05-25 12:52:36 +02:00
"github.com/prometheus/client_golang/prometheus"
2022-03-22 13:17:50 -06:00
"cdr.dev/slog"
"cdr.dev/slog/sloggers/sloghuman"
2023-05-24 07:32:40 -07:00
"cdr.dev/slog/sloggers/slogjson"
"cdr.dev/slog/sloggers/slogstackdriver"
2025-05-14 14:15:36 +02:00
"github.com/coder/serpent"
2023-08-18 13:55:43 -05:00
"github.com/coder/coder/v2/agent"
2025-06-10 12:37:54 +03:00
"github.com/coder/coder/v2/agent/agentcontainers"
2024-11-27 20:12:15 +02:00
"github.com/coder/coder/v2/agent/agentexec"
2024-06-10 14:12:23 +02:00
"github.com/coder/coder/v2/agent/agentssh"
2023-08-18 13:55:43 -05:00
"github.com/coder/coder/v2/agent/reaper"
"github.com/coder/coder/v2/buildinfo"
2024-11-19 19:47:35 +11:00
"github.com/coder/coder/v2/cli/clilog"
2023-08-18 13:55:43 -05:00
"github.com/coder/coder/v2/codersdk"
"github.com/coder/coder/v2/codersdk/agentsdk"
2022-03-07 11:40:54 -06:00
)
2024-03-17 09:45:26 -05:00
func ( r * RootCmd ) workspaceAgent () * serpent . Command {
2022-03-25 13:48:08 -06:00
var (
2025-08-04 16:21:13 +01:00
auth string
logDir string
scriptDataDir string
pprofAddress string
noReap bool
sshMaxTimeout time . Duration
tailnetListenPort int64
prometheusAddress string
debugAddress string
slogHumanPath string
slogJSONPath string
slogStackdriverPath string
blockFileTransfer bool
agentHeaderCommand string
agentHeader [] string
devcontainers bool
devcontainerProjectDiscovery bool
devcontainerDiscoveryAutostart bool
2022-03-25 13:48:08 -06:00
)
2024-03-17 09:45:26 -05:00
cmd := & serpent . Command {
2023-03-23 17:42:20 -05:00
Use : "agent" ,
Short : `Starts the Coder workspace agent.` ,
2022-03-25 10:34:45 -06:00
// This command isn't useful to manually execute.
2022-03-07 11:40:54 -06:00
Hidden : true ,
2024-03-15 11:24:38 -05:00
Handler : func ( inv * serpent . Invocation ) error {
2025-05-14 14:15:36 +02:00
ctx , cancel := context . WithCancelCause ( inv . Context ())
defer func () {
cancel ( xerrors . New ( "agent exited" ))
}()
2022-11-14 13:48:44 +02:00
2023-06-02 15:51:10 -05:00
var (
ignorePorts = map [ int ] string {}
isLinux = runtime . GOOS == "linux"
2022-05-02 11:36:51 -05:00
2023-06-02 15:51:10 -05:00
sinks = [] slog . Sink {}
logClosers = [] func () error {}
)
defer func () {
for _ , closer := range logClosers {
_ = closer ()
}
}()
addSinkIfProvided := func ( sinkFn func ( io . Writer ) slog . Sink , loc string ) error {
switch loc {
case "" :
// Do nothing.
case "/dev/stderr" :
sinks = append ( sinks , sinkFn ( inv . Stderr ))
case "/dev/stdout" :
sinks = append ( sinks , sinkFn ( inv . Stdout ))
default :
fi , err := os . OpenFile ( loc , os . O_WRONLY | os . O_CREATE | os . O_APPEND , 0 o644 )
if err != nil {
return xerrors . Errorf ( "open log file %q: %w" , loc , err )
}
sinks = append ( sinks , sinkFn ( fi ))
logClosers = append ( logClosers , fi . Close )
}
return nil
}
if err := addSinkIfProvided ( sloghuman . Sink , slogHumanPath ); err != nil {
return xerrors . Errorf ( "add human sink: %w" , err )
}
if err := addSinkIfProvided ( slogjson . Sink , slogJSONPath ); err != nil {
return xerrors . Errorf ( "add json sink: %w" , err )
}
if err := addSinkIfProvided ( slogstackdriver . Sink , slogStackdriverPath ); err != nil {
return xerrors . Errorf ( "add stackdriver sink: %w" , err )
}
2022-06-17 11:51:46 -05:00
// Spawn a reaper so that we don't accumulate a ton
// of zombie processes.
2022-06-21 18:01:34 -05:00
if reaper . IsInitProcess () && ! noReap && isLinux {
2024-11-19 19:47:35 +11:00
logWriter := & clilog . LumberjackWriteCloseFixer { Writer : & lumberjack . Logger {
2023-01-30 18:39:52 +02:00
Filename : filepath . Join ( logDir , "coder-agent-init.log" ),
2023-01-30 15:59:13 +02:00
MaxSize : 5 , // MB
2023-06-02 12:28:38 -05:00
// Without this, rotated logs will never be deleted.
MaxBackups : 1 ,
2023-06-27 15:49:44 +03:00
}}
2023-01-30 15:59:13 +02:00
defer logWriter . Close ()
2023-05-24 07:32:40 -07:00
2023-06-02 15:51:10 -05:00
sinks = append ( sinks , sloghuman . Sink ( logWriter ))
2023-11-14 22:56:27 +04:00
logger := inv . Logger . AppendSinks ( sinks ... ). Leveled ( slog . LevelDebug )
2023-01-30 15:59:13 +02:00
2022-11-14 13:48:44 +02:00
logger . Info ( ctx , "spawning reaper process" )
2022-06-21 18:01:34 -05:00
// Do not start a reaper on the child process. It's important
// to do this else we fork bomb ourselves.
2025-03-26 01:56:39 -05:00
//nolint:gocritic
2022-06-21 18:01:34 -05:00
args := append ( os . Args , "--no-reap" )
2023-02-09 23:07:21 +02:00
err := reaper . ForkReap (
reaper . WithExecArgs ( args ... ),
2024-03-15 14:16:36 +01:00
reaper . WithCatchSignals ( StopSignals ... ),
2023-02-09 23:07:21 +02:00
)
2022-06-17 11:51:46 -05:00
if err != nil {
2023-06-20 12:30:45 +02:00
logger . Error ( ctx , "agent process reaper unable to fork" , slog . Error ( err ))
2022-06-17 11:51:46 -05:00
return xerrors . Errorf ( "fork reap: %w" , err )
}
2022-11-14 13:48:44 +02:00
logger . Info ( ctx , "reaper process exiting" )
2022-06-17 11:51:46 -05:00
return nil
}
2023-01-30 15:59:13 +02:00
// Handle interrupt signals to allow for graceful shutdown,
// note that calling stopNotify disables the signal handler
// and the next interrupt will terminate the program (you
// probably want cancel instead).
//
// Note that we don't want to handle these signals in the
// process that runs as PID 1, that's why we do this after
// the reaper forked.
2024-03-15 14:16:36 +01:00
ctx , stopNotify := inv . SignalNotifyContext ( ctx , StopSignals ... )
2023-01-30 15:59:13 +02:00
defer stopNotify ()
2023-04-13 09:07:19 -05:00
// DumpHandler does signal handling, so we call it after the
2023-01-30 15:59:13 +02:00
// reaper.
2024-03-04 18:35:33 +02:00
go DumpHandler ( ctx , "agent" )
2023-01-30 15:59:13 +02:00
2024-11-19 19:47:35 +11:00
logWriter := & clilog . LumberjackWriteCloseFixer { Writer : & lumberjack . Logger {
2023-01-30 18:39:52 +02:00
Filename : filepath . Join ( logDir , "coder-agent.log" ),
2023-01-30 15:59:13 +02:00
MaxSize : 5 , // MB
2023-11-18 10:53:56 -06:00
// Per customer incident on November 17th, 2023, its helpful
// to have the log of the last few restarts to debug a failing agent.
MaxBackups : 10 ,
2023-06-27 15:49:44 +03:00
}}
2023-01-30 15:59:13 +02:00
defer logWriter . Close ()
2023-02-01 16:04:09 +02:00
2023-06-02 15:51:10 -05:00
sinks = append ( sinks , sloghuman . Sink ( logWriter ))
2023-11-14 22:56:27 +04:00
logger := inv . Logger . AppendSinks ( sinks ... ). Leveled ( slog . LevelDebug )
2023-01-30 15:59:13 +02:00
2022-08-31 16:33:50 +01:00
version := buildinfo . Version ()
2023-06-20 12:30:45 +02:00
logger . Info ( ctx , "agent is starting now" ,
2023-03-23 17:42:20 -05:00
slog . F ( "url" , r . agentURL ),
2022-08-31 16:33:50 +01:00
slog . F ( "auth" , auth ),
slog . F ( "version" , version ),
)
2024-11-27 20:12:15 +02:00
2023-03-23 17:42:20 -05:00
client := agentsdk . New ( r . agentURL )
2023-07-06 09:43:39 +01:00
client . SDK . SetLogger ( logger )
2022-10-23 22:35:08 -05:00
// Set a reasonable timeout so requests can't hang forever!
2023-03-23 14:09:13 -05:00
// The timeout needs to be reasonably long, because requests
// with large payloads can take a bit. e.g. startup scripts
// may take a while to insert.
client . SDK . HTTPClient . Timeout = 30 * time . Second
2024-08-29 14:15:15 +10:00
// Attach header transport so we process --agent-header and
// --agent-header-command flags
headerTransport , err := headerTransport ( ctx , r . agentURL , agentHeader , agentHeaderCommand )
if err != nil {
return xerrors . Errorf ( "configure header transport: %w" , err )
}
headerTransport . Transport = client . SDK . HTTPClient . Transport
client . SDK . HTTPClient . Transport = headerTransport
2022-03-28 13:31:03 -06:00
2022-11-08 15:02:07 +01:00
// Enable pprof handler
// This prevents the pprof import from being accidentally deleted.
_ = pprof . Handler
2023-04-13 09:07:19 -05:00
pprofSrvClose := ServeHandler ( ctx , logger , nil , pprofAddress , "pprof" )
2022-11-08 15:02:07 +01:00
defer pprofSrvClose ()
2023-05-23 17:14:05 +02:00
if port , err := extractPort ( pprofAddress ); err == nil {
2023-04-26 13:01:49 -05:00
ignorePorts [ port ] = "pprof"
2023-03-09 10:53:00 -06:00
}
2022-06-06 16:38:33 +03:00
2023-05-23 17:14:05 +02:00
if port , err := extractPort ( prometheusAddress ); err == nil {
2023-04-26 13:01:49 -05:00
ignorePorts [ port ] = "prometheus"
2023-04-19 09:09:23 +02:00
}
2023-05-23 17:14:05 +02:00
if port , err := extractPort ( debugAddress ); err == nil {
ignorePorts [ port ] = "debug"
}
2022-03-28 13:31:03 -06:00
// exchangeToken returns a session token.
// This is abstracted to allow for the same looping condition
// regardless of instance identity auth type.
2023-01-29 15:47:24 -06:00
var exchangeToken func ( context . Context ) ( agentsdk . AuthenticateResponse , error )
2022-03-25 10:34:45 -06:00
switch auth {
case "token" :
2023-10-05 15:41:05 -05:00
token , _ := inv . ParsedFlags (). GetString ( varAgentToken )
if token == "" {
tokenFile , _ := inv . ParsedFlags (). GetString ( varAgentTokenFile )
if tokenFile != "" {
tokenBytes , err := os . ReadFile ( tokenFile )
if err != nil {
return xerrors . Errorf ( "read token file %q: %w" , tokenFile , err )
}
token = strings . TrimSpace ( string ( tokenBytes ))
}
}
if token == "" {
return xerrors . Errorf ( "CODER_AGENT_TOKEN or CODER_AGENT_TOKEN_FILE must be set for token auth" )
2022-03-25 10:34:45 -06:00
}
2022-11-09 15:31:24 +02:00
client . SetSessionToken ( token )
2022-03-25 10:34:45 -06:00
case "google-instance-identity" :
2022-03-25 13:48:08 -06:00
// This is *only* done for testing to mock client authentication.
// This will never be set in a production scenario.
var gcpClient * metadata . Client
2022-11-14 13:48:44 +02:00
gcpClientRaw := ctx . Value ( "gcp-client" )
2022-03-25 13:48:08 -06:00
if gcpClientRaw != nil {
gcpClient , _ = gcpClientRaw .( * metadata . Client )
}
2023-01-29 15:47:24 -06:00
exchangeToken = func ( ctx context . Context ) ( agentsdk . AuthenticateResponse , error ) {
return client . AuthGoogleInstanceIdentity ( ctx , "" , gcpClient )
2022-03-28 13:31:03 -06:00
}
case "aws-instance-identity" :
// This is *only* done for testing to mock client authentication.
// This will never be set in a production scenario.
var awsClient * http . Client
2022-11-14 13:48:44 +02:00
awsClientRaw := ctx . Value ( "aws-client" )
2022-03-28 13:31:03 -06:00
if awsClientRaw != nil {
awsClient , _ = awsClientRaw .( * http . Client )
if awsClient != nil {
2023-01-29 15:47:24 -06:00
client . SDK . HTTPClient = awsClient
2022-03-28 13:31:03 -06:00
}
}
2023-01-29 15:47:24 -06:00
exchangeToken = func ( ctx context . Context ) ( agentsdk . AuthenticateResponse , error ) {
return client . AuthAWSInstanceIdentity ( ctx )
2022-03-28 13:31:03 -06:00
}
case "azure-instance-identity" :
2022-04-19 08:48:13 -05:00
// This is *only* done for testing to mock client authentication.
// This will never be set in a production scenario.
var azureClient * http . Client
2022-11-14 13:48:44 +02:00
azureClientRaw := ctx . Value ( "azure-client" )
2022-04-19 08:48:13 -05:00
if azureClientRaw != nil {
azureClient , _ = azureClientRaw .( * http . Client )
if azureClient != nil {
2023-01-29 15:47:24 -06:00
client . SDK . HTTPClient = azureClient
2022-04-19 08:48:13 -05:00
}
}
2023-01-29 15:47:24 -06:00
exchangeToken = func ( ctx context . Context ) ( agentsdk . AuthenticateResponse , error ) {
return client . AuthAzureInstanceIdentity ( ctx )
2022-04-19 08:48:13 -05:00
}
2022-03-28 13:31:03 -06:00
}
2022-03-25 13:48:08 -06:00
2022-06-17 00:54:45 -05:00
executablePath , err := os . Executable ()
if err != nil {
return xerrors . Errorf ( "getting os executable: %w" , err )
}
err = os . Setenv ( "PATH" , fmt . Sprintf ( "%s%c%s" , os . Getenv ( "PATH" ), filepath . ListSeparator , filepath . Dir ( executablePath )))
if err != nil {
return xerrors . Errorf ( "add executable to $PATH: %w" , err )
}
2023-08-08 22:10:28 -07:00
subsystemsRaw := inv . Environ . Get ( agent . EnvAgentSubsystem )
subsystems := [] codersdk . AgentSubsystem {}
for _ , s := range strings . Split ( subsystemsRaw , "," ) {
subsystem := codersdk . AgentSubsystem ( strings . TrimSpace ( s ))
if subsystem == "" {
continue
}
if ! subsystem . Valid () {
return xerrors . Errorf ( "invalid subsystem %q" , subsystem )
}
subsystems = append ( subsystems , subsystem )
}
2024-02-19 16:30:00 +02:00
environmentVariables := map [ string ] string {
"GIT_ASKPASS" : executablePath ,
}
2024-11-27 20:12:15 +02:00
enabled := os . Getenv ( agentexec . EnvProcPrioMgmt )
if enabled != "" && runtime . GOOS == "linux" {
logger . Info ( ctx , "process priority management enabled" ,
slog . F ( "env_var" , agentexec . EnvProcPrioMgmt ),
slog . F ( "enabled" , enabled ),
slog . F ( "os" , runtime . GOOS ),
)
} else {
logger . Info ( ctx , "process priority management not enabled (linux-only) " ,
slog . F ( "env_var" , agentexec . EnvProcPrioMgmt ),
slog . F ( "enabled" , enabled ),
slog . F ( "os" , runtime . GOOS ),
)
2024-04-03 09:42:03 -05:00
}
2024-02-19 16:30:00 +02:00
2024-12-04 23:30:25 +02:00
execer , err := agentexec . NewExecer ()
if err != nil {
return xerrors . Errorf ( "create agent execer: %w" , err )
}
2025-06-24 21:17:04 +03:00
if devcontainers {
2025-02-11 15:29:59 +00:00
logger . Info ( ctx , "agent devcontainer detection enabled" )
2025-04-29 17:53:10 +03:00
} else {
logger . Info ( ctx , "agent devcontainer detection not enabled" )
2025-02-11 15:29:59 +00:00
}
2025-05-14 14:15:36 +02:00
reinitEvents := agentsdk . WaitForReinitLoop ( ctx , logger , client )
2023-05-25 12:52:36 +02:00
2025-05-14 14:15:36 +02:00
var (
lastErr error
mustExit bool
)
for {
prometheusRegistry := prometheus . NewRegistry ()
2025-02-26 09:03:27 +00:00
2025-05-14 14:15:36 +02:00
agnt := agent . New ( agent . Options {
Client : client ,
Logger : logger ,
LogDir : logDir ,
ScriptDataDir : scriptDataDir ,
// #nosec G115 - Safe conversion as tailnet listen port is within uint16 range (0-65535)
TailnetListenPort : uint16 ( tailnetListenPort ),
ExchangeToken : func ( ctx context . Context ) ( string , error ) {
if exchangeToken == nil {
return client . SDK . SessionToken (), nil
}
resp , err := exchangeToken ( ctx )
if err != nil {
return "" , err
}
client . SetSessionToken ( resp . SessionToken )
return resp . SessionToken , nil
},
EnvironmentVariables : environmentVariables ,
IgnorePorts : ignorePorts ,
SSHMaxTimeout : sshMaxTimeout ,
Subsystems : subsystems ,
2023-04-26 13:01:49 -05:00
2025-06-24 21:17:04 +03:00
PrometheusRegistry : prometheusRegistry ,
BlockFileTransfer : blockFileTransfer ,
Execer : execer ,
Devcontainers : devcontainers ,
DevcontainerAPIOptions : [] agentcontainers . Option {
2025-06-10 12:37:54 +03:00
agentcontainers . WithSubAgentURL ( r . agentURL . String ()),
2025-07-22 19:02:43 +01:00
agentcontainers . WithProjectDiscovery ( devcontainerProjectDiscovery ),
2025-08-04 16:21:13 +01:00
agentcontainers . WithDiscoveryAutostart ( devcontainerDiscoveryAutostart ),
2025-06-10 12:37:54 +03:00
},
2025-05-14 14:15:36 +02:00
})
2023-05-25 12:52:36 +02:00
2025-05-14 14:15:36 +02:00
promHandler := agent . PrometheusMetricsHandler ( prometheusRegistry , logger )
prometheusSrvClose := ServeHandler ( ctx , logger , promHandler , prometheusAddress , "prometheus" )
2023-04-26 13:01:49 -05:00
2025-05-14 14:15:36 +02:00
debugSrvClose := ServeHandler ( ctx , logger , agnt . HTTPDebug (), debugAddress , "debug" )
select {
case <- ctx . Done ():
logger . Info ( ctx , "agent shutting down" , slog . Error ( context . Cause ( ctx )))
mustExit = true
case event := <- reinitEvents :
logger . Info ( ctx , "agent received instruction to reinitialize" ,
slog . F ( "workspace_id" , event . WorkspaceID ), slog . F ( "reason" , event . Reason ))
}
lastErr = agnt . Close ()
debugSrvClose ()
prometheusSrvClose ()
if mustExit {
break
}
logger . Info ( ctx , "agent reinitializing" )
}
return lastErr
2022-03-07 11:40:54 -06:00
},
}
2022-03-28 14:26:41 -05:00
2024-03-15 11:24:38 -05:00
cmd . Options = serpent . OptionSet {
2023-03-23 17:42:20 -05:00
{
Flag : "auth" ,
Default : "token" ,
Description : "Specify the authentication type to use for the agent." ,
Env : "CODER_AGENT_AUTH" ,
2024-03-15 11:24:38 -05:00
Value : serpent . StringOf ( & auth ),
2023-03-23 17:42:20 -05:00
},
{
Flag : "log-dir" ,
Default : os . TempDir (),
Description : "Specify the location for the agent log files." ,
Env : "CODER_AGENT_LOG_DIR" ,
2024-03-15 11:24:38 -05:00
Value : serpent . StringOf ( & logDir ),
2023-03-23 17:42:20 -05:00
},
2024-02-20 13:26:18 +02:00
{
Flag : "script-data-dir" ,
Default : os . TempDir (),
Description : "Specify the location for storing script data." ,
Env : "CODER_AGENT_SCRIPT_DATA_DIR" ,
2024-03-15 11:24:38 -05:00
Value : serpent . StringOf ( & scriptDataDir ),
2024-02-20 13:26:18 +02:00
},
2023-03-23 17:42:20 -05:00
{
Flag : "pprof-address" ,
Default : "127.0.0.1:6060" ,
Env : "CODER_AGENT_PPROF_ADDRESS" ,
2024-03-15 11:24:38 -05:00
Value : serpent . StringOf ( & pprofAddress ),
2023-03-23 17:42:20 -05:00
Description : "The address to serve pprof." ,
},
2024-08-29 14:15:15 +10:00
{
Flag : "agent-header-command" ,
Env : "CODER_AGENT_HEADER_COMMAND" ,
Value : serpent . StringOf ( & agentHeaderCommand ),
Description : "An external command that outputs additional HTTP headers added to all requests. The command must output each header as `key=value` on its own line." ,
},
{
Flag : "agent-header" ,
Env : "CODER_AGENT_HEADER" ,
Value : serpent . StringArrayOf ( & agentHeader ),
Description : "Additional HTTP headers added to all requests. Provide as " + `key=value` + ". Can be specified multiple times." ,
},
2023-03-23 17:42:20 -05:00
{
Flag : "no-reap" ,
Env : "" ,
Description : "Do not start a process reaper." ,
2024-03-15 11:24:38 -05:00
Value : serpent . BoolOf ( & noReap ),
2023-03-23 17:42:20 -05:00
},
{
2023-06-16 15:22:18 +02:00
Flag : "ssh-max-timeout" ,
// tcpip.KeepaliveIdleOption = 72h + 1min (forwardTCPSockOpts() in tailnet/conn.go)
Default : "72h" ,
2023-03-23 17:42:20 -05:00
Env : "CODER_AGENT_SSH_MAX_TIMEOUT" ,
2023-06-16 15:22:18 +02:00
Description : "Specify the max timeout for a SSH connection, it is advisable to set it to a minimum of 60s, but no more than 72h." ,
2024-03-15 11:24:38 -05:00
Value : serpent . DurationOf ( & sshMaxTimeout ),
2023-03-23 17:42:20 -05:00
},
2023-04-03 11:20:19 -05:00
{
Flag : "tailnet-listen-port" ,
Default : "0" ,
Env : "CODER_AGENT_TAILNET_LISTEN_PORT" ,
Description : "Specify a static port for Tailscale to use for listening." ,
2024-03-15 11:24:38 -05:00
Value : serpent . Int64Of ( & tailnetListenPort ),
2023-04-03 11:20:19 -05:00
},
2023-04-19 09:09:23 +02:00
{
Flag : "prometheus-address" ,
Default : "127.0.0.1:2112" ,
Env : "CODER_AGENT_PROMETHEUS_ADDRESS" ,
2024-03-15 11:24:38 -05:00
Value : serpent . StringOf ( & prometheusAddress ),
2023-04-19 09:09:23 +02:00
Description : "The bind address to serve Prometheus metrics." ,
},
2023-04-26 13:01:49 -05:00
{
Flag : "debug-address" ,
Default : "127.0.0.1:2113" ,
Env : "CODER_AGENT_DEBUG_ADDRESS" ,
2024-03-15 11:24:38 -05:00
Value : serpent . StringOf ( & debugAddress ),
2023-04-26 13:01:49 -05:00
Description : "The bind address to serve a debug HTTP server." ,
},
2023-05-24 07:32:40 -07:00
{
Name : "Human Log Location" ,
Description : "Output human-readable logs to a given file." ,
Flag : "log-human" ,
Env : "CODER_AGENT_LOGGING_HUMAN" ,
Default : "/dev/stderr" ,
2024-03-15 11:24:38 -05:00
Value : serpent . StringOf ( & slogHumanPath ),
2023-05-24 07:32:40 -07:00
},
{
Name : "JSON Log Location" ,
Description : "Output JSON logs to a given file." ,
Flag : "log-json" ,
Env : "CODER_AGENT_LOGGING_JSON" ,
Default : "" ,
2024-03-15 11:24:38 -05:00
Value : serpent . StringOf ( & slogJSONPath ),
2023-05-24 07:32:40 -07:00
},
{
Name : "Stackdriver Log Location" ,
Description : "Output Stackdriver compatible logs to a given file." ,
Flag : "log-stackdriver" ,
Env : "CODER_AGENT_LOGGING_STACKDRIVER" ,
Default : "" ,
2024-03-15 11:24:38 -05:00
Value : serpent . StringOf ( & slogStackdriverPath ),
2023-05-24 07:32:40 -07:00
},
2024-06-10 14:12:23 +02:00
{
Flag : "block-file-transfer" ,
Default : "false" ,
Env : "CODER_AGENT_BLOCK_FILE_TRANSFER" ,
Description : fmt . Sprintf ( "Block file transfer using known applications: %s." , strings . Join ( agentssh . BlockedFileTransferCommands , "," )),
Value : serpent . BoolOf ( & blockFileTransfer ),
},
2025-02-11 15:29:59 +00:00
{
Flag : "devcontainers-enable" ,
2025-06-24 21:17:04 +03:00
Default : "true" ,
2025-02-11 15:29:59 +00:00
Env : "CODER_AGENT_DEVCONTAINERS_ENABLE" ,
Description : "Allow the agent to automatically detect running devcontainers." ,
2025-06-24 21:17:04 +03:00
Value : serpent . BoolOf ( & devcontainers ),
2025-02-11 15:29:59 +00:00
},
2025-07-22 19:02:43 +01:00
{
Flag : "devcontainers-project-discovery-enable" ,
Default : "true" ,
Env : "CODER_AGENT_DEVCONTAINERS_PROJECT_DISCOVERY_ENABLE" ,
Description : "Allow the agent to search the filesystem for devcontainer projects." ,
Value : serpent . BoolOf ( & devcontainerProjectDiscovery ),
},
2025-08-04 16:21:13 +01:00
{
Flag : "devcontainers-discovery-autostart-enable" ,
Default : "false" ,
Env : "CODER_AGENT_DEVCONTAINERS_DISCOVERY_AUTOSTART_ENABLE" ,
Description : "Allow the agent to autostart devcontainer projects it discovers based on their configuration." ,
Value : serpent . BoolOf ( & devcontainerDiscoveryAutostart ),
},
2023-03-23 17:42:20 -05:00
}
2022-03-25 13:48:08 -06:00
return cmd
2022-03-07 11:40:54 -06:00
}
2023-01-17 10:58:00 -06:00
2023-04-13 09:07:19 -05:00
func ServeHandler ( ctx context . Context , logger slog . Logger , handler http . Handler , addr , name string ) ( closeFunc func ()) {
2023-01-17 10:58:00 -06:00
// ReadHeaderTimeout is purposefully not enabled. It caused some issues with
// websockets over the dev tunnel.
// See: https://github.com/coder/coder/pull/3730
//nolint:gosec
srv := & http . Server {
Addr : addr ,
Handler : handler ,
}
go func () {
2025-04-09 09:20:47 +01:00
ln , err := net . Listen ( "tcp" , addr )
if err != nil {
logger . Error ( ctx , "http server listen" , slog . F ( "name" , name ), slog . F ( "addr" , addr ), slog . Error ( err ))
return
}
defer ln . Close ()
logger . Info ( ctx , "http server listening" , slog . F ( "addr" , ln . Addr ()), slog . F ( "name" , name ))
if err := srv . Serve ( ln ); err != nil && ! xerrors . Is ( err , http . ErrServerClosed ) {
logger . Error ( ctx , "http server serve" , slog . F ( "addr" , ln . Addr ()), slog . F ( "name" , name ), slog . Error ( err ))
2023-01-17 10:58:00 -06:00
}
}()
return func () {
_ = srv . Close ()
}
}
2023-02-01 16:04:09 +02:00
2023-03-09 10:53:00 -06:00
// extractPort handles different url strings.
// - localhost:6060
// - http://localhost:6060
func extractPort ( u string ) ( int , error ) {
port , firstError := urlPort ( u )
if firstError == nil {
return port , nil
}
// Try with a scheme
port , err := urlPort ( "http://" + u )
if err == nil {
return port , nil
}
return - 1 , xerrors . Errorf ( "invalid url %q: %w" , u , firstError )
}
// urlPort extracts the port from a valid URL.
func urlPort ( u string ) ( int , error ) {
parsed , err := url . Parse ( u )
if err != nil {
return - 1 , xerrors . Errorf ( "invalid url %q: %w" , u , err )
}
if parsed . Port () != "" {
2023-04-06 07:43:24 +10:00
port , err := strconv . ParseUint ( parsed . Port (), 10 , 16 )
if err == nil && port > 0 && port < 1 << 16 {
2023-03-09 10:53:00 -06:00
return int ( port ), nil
}
}
return - 1 , xerrors . Errorf ( "invalid port: %s" , u )
}