package coderd

import (

"context"

"crypto/tls"

"crypto/x509"

"database/sql"

"errors"

"expvar"

"flag"

"fmt"

"io"

"math"

"net/http"

httppprof "net/http/pprof"

"net/url"

"path/filepath"

"regexp"

"runtime/pprof"

"strings"

"sync"

"sync/atomic"

"time"

"github.com/go-chi/chi/v5"

"github.com/go-chi/chi/v5/middleware"

"github.com/google/uuid"

"github.com/prometheus/client_golang/prometheus"

"github.com/prometheus/client_golang/prometheus/collectors"

"github.com/prometheus/client_golang/prometheus/promhttp"

httpSwagger "github.com/swaggo/http-swagger/v2"

"go.opentelemetry.io/otel/trace"

"golang.org/x/xerrors"

"google.golang.org/api/idtoken"

"storj.io/drpc/drpcmux"

"storj.io/drpc/drpcserver"

"tailscale.com/derp"

"tailscale.com/derp/derphttp"

"tailscale.com/tailcfg"

"tailscale.com/types/key"

"tailscale.com/util/singleflight"

"cdr.dev/slog/v3"

agentproto "github.com/coder/coder/v2/agent/proto"

"github.com/coder/coder/v2/buildinfo"

"github.com/coder/coder/v2/coderd/agentapi"

"github.com/coder/coder/v2/coderd/agentapi/metadatabatcher"

"github.com/coder/coder/v2/coderd/aiseats"

_ "github.com/coder/coder/v2/coderd/apidoc" // Used for swagger docs.

"github.com/coder/coder/v2/coderd/appearance"

"github.com/coder/coder/v2/coderd/audit"

"github.com/coder/coder/v2/coderd/awsidentity"

"github.com/coder/coder/v2/coderd/boundaryusage"

"github.com/coder/coder/v2/coderd/chatd"

"github.com/coder/coder/v2/coderd/connectionlog"

"github.com/coder/coder/v2/coderd/cryptokeys"

"github.com/coder/coder/v2/coderd/database"

"github.com/coder/coder/v2/coderd/database/dbauthz"

"github.com/coder/coder/v2/coderd/database/dbrollup"

"github.com/coder/coder/v2/coderd/database/dbtime"

"github.com/coder/coder/v2/coderd/database/pubsub"

"github.com/coder/coder/v2/coderd/entitlements"

"github.com/coder/coder/v2/coderd/externalauth"

"github.com/coder/coder/v2/coderd/files"

"github.com/coder/coder/v2/coderd/gitsshkey"

"github.com/coder/coder/v2/coderd/gitsync"

"github.com/coder/coder/v2/coderd/healthcheck"

"github.com/coder/coder/v2/coderd/healthcheck/derphealth"

"github.com/coder/coder/v2/coderd/httpapi"

"github.com/coder/coder/v2/coderd/httpmw"

"github.com/coder/coder/v2/coderd/httpmw/loggermw"

"github.com/coder/coder/v2/coderd/idpsync"

"github.com/coder/coder/v2/coderd/metricscache"

"github.com/coder/coder/v2/coderd/notifications"

"github.com/coder/coder/v2/coderd/oauth2provider"

"github.com/coder/coder/v2/coderd/portsharing"

"github.com/coder/coder/v2/coderd/pproflabel"

"github.com/coder/coder/v2/coderd/prebuilds"

"github.com/coder/coder/v2/coderd/prometheusmetrics"

"github.com/coder/coder/v2/coderd/provisionerdserver"

"github.com/coder/coder/v2/coderd/proxyhealth"

"github.com/coder/coder/v2/coderd/rbac"

"github.com/coder/coder/v2/coderd/rbac/policy"

"github.com/coder/coder/v2/coderd/rbac/rolestore"

"github.com/coder/coder/v2/coderd/runtimeconfig"

"github.com/coder/coder/v2/coderd/schedule"

"github.com/coder/coder/v2/coderd/telemetry"

"github.com/coder/coder/v2/coderd/tracing"

"github.com/coder/coder/v2/coderd/updatecheck"

"github.com/coder/coder/v2/coderd/usage"

"github.com/coder/coder/v2/coderd/util/slice"

"github.com/coder/coder/v2/coderd/webpush"

"github.com/coder/coder/v2/coderd/workspaceapps"

"github.com/coder/coder/v2/coderd/workspaceapps/appurl"

"github.com/coder/coder/v2/coderd/workspacestats"

"github.com/coder/coder/v2/coderd/wsbuilder"

"github.com/coder/coder/v2/codersdk"

"github.com/coder/coder/v2/codersdk/drpcsdk"

"github.com/coder/coder/v2/codersdk/healthsdk"

sharedhttpmw "github.com/coder/coder/v2/httpmw"

"github.com/coder/coder/v2/provisionerd/proto"

"github.com/coder/coder/v2/provisionersdk"

"github.com/coder/coder/v2/site"

"github.com/coder/coder/v2/tailnet"

"github.com/coder/coder/v2/tailnet/derpmetrics"

"github.com/coder/quartz"

"github.com/coder/serpent"

)

// We must only ever instantiate one httpSwagger.Handler because of a data race

// inside the handler. This issue is triggered by tests that create multiple

// coderd instances.

//

// See https://github.com/swaggo/http-swagger/issues/78

var globalHTTPSwaggerHandler http.HandlerFunc

func init() {

globalHTTPSwaggerHandler = httpSwagger.Handler(

httpSwagger.URL("/swagger/doc.json"),

// The swagger UI has an "Authorize" button that will input the

// credentials into the Coder-Session-Token header. This bypasses

// CSRF checks **if** there is no cookie auth also present.

// (If the cookie matches, then it's ok too)

//

// Because swagger is hosted on the same domain, we have the cookie

// auth and the header auth competing. This can cause CSRF errors,

// and can be confusing what authentication is being used.

//

// So remove authenticating via a cookie, and rely on the authorization

// header passed in.

httpSwagger.UIConfig(map[string]string{

// Pulled from https://swagger.io/docs/open-source-tools/swagger-ui/usage/configuration/

// 'withCredentials' should disable fetch sending browser credentials, but

// for whatever reason it does not.

// So this `requestInterceptor` ensures browser credentials are

// omitted from all requests.

"requestInterceptor": `(a => {

a.credentials = "omit";

return a;

})`,

"withCredentials": "false",

}))

}

var expDERPOnce = sync.Once{}

// Options are requires parameters for Coder to start.

type Options struct {

AccessURL *url.URL

// AppHostname should be the wildcard hostname to use for workspace

// applications INCLUDING the asterisk, (optional) suffix and leading dot.

// It will use the same scheme and port number as the access URL.

// E.g. "*.apps.coder.com" or "*-apps.coder.com" or "*.apps.coder.com:8080".

AppHostname string

// AppHostnameRegex contains the regex version of options.AppHostname as

// generated by appurl.CompileHostnamePattern(). It MUST be set if

// options.AppHostname is set.

AppHostnameRegex *regexp.Regexp

Logger slog.Logger

Database database.Store

Pubsub pubsub.Pubsub

RuntimeConfig *runtimeconfig.Manager

// CacheDir is used for caching files served by the API.

CacheDir string

Auditor audit.Auditor

ConnectionLogger connectionlog.ConnectionLogger

AgentConnectionUpdateFrequency time.Duration

AgentInactiveDisconnectTimeout time.Duration

AWSCertificates awsidentity.Certificates

Authorizer rbac.Authorizer

AzureCertificates x509.VerifyOptions

GoogleTokenValidator *idtoken.Validator

GithubOAuth2Config *GithubOAuth2Config

OIDCConfig *OIDCConfig

PrometheusRegistry *prometheus.Registry

StrictTransportSecurityCfg httpmw.HSTSConfig

SSHKeygenAlgorithm gitsshkey.Algorithm

Telemetry telemetry.Reporter

TracerProvider trace.TracerProvider

ExternalAuthConfigs []*externalauth.Config

RealIPConfig *httpmw.RealIPConfig

TrialGenerator func(ctx context.Context, body codersdk.LicensorTrialRequest) error

// RefreshEntitlements is used to set correct entitlements after creating first user and generating trial license.

RefreshEntitlements func(ctx context.Context) error

// Entitlements can come from the enterprise caller if enterprise code is

// included.

Entitlements *entitlements.Set

// PostAuthAdditionalHeadersFunc is used to add additional headers to the response

// after a successful authentication.

// This is somewhat janky, but seemingly the only reasonable way to add a header

// for all authenticated users under a condition, only in Enterprise.

PostAuthAdditionalHeadersFunc func(auth rbac.Subject, header http.Header)

// TLSCertificates is used to mesh DERP servers securely.

TLSCertificates []tls.Certificate

TailnetCoordinator tailnet.Coordinator

DERPServer *derp.Server

// BaseDERPMap is used as the base DERP map for all clients and agents.

// Proxies are added to this list.

BaseDERPMap *tailcfg.DERPMap

DERPMapUpdateFrequency time.Duration

NetworkTelemetryBatchFrequency time.Duration

NetworkTelemetryBatchMaxSize int

SwaggerEndpoint bool

TemplateScheduleStore *atomic.Pointer[schedule.TemplateScheduleStore]

UserQuietHoursScheduleStore *atomic.Pointer[schedule.UserQuietHoursScheduleStore]

AccessControlStore *atomic.Pointer[dbauthz.AccessControlStore]

UsageInserter *atomic.Pointer[usage.Inserter]

// CoordinatorResumeTokenProvider is used to provide and validate resume

// tokens issued by and passed to the coordinator DRPC API.

CoordinatorResumeTokenProvider tailnet.ResumeTokenProvider

HealthcheckFunc func(ctx context.Context, apiKey string, progress *healthcheck.Progress) *healthsdk.HealthcheckReport

HealthcheckTimeout time.Duration

HealthcheckRefresh time.Duration

WorkspaceProxiesFetchUpdater *atomic.Pointer[healthcheck.WorkspaceProxiesFetchUpdater]

// OAuthSigningKey is the crypto key used to sign and encrypt state strings

// related to OAuth. This is a symmetric secret key using hmac to sign payloads.

// So this secret should **never** be exposed to the client.

OAuthSigningKey [32]byte

// APIRateLimit is the minutely throughput rate limit per user or ip.

// Setting a rate limit <0 will disable the rate limiter across the entire

// app. Some specific routes have their own configurable rate limits.

APIRateLimit int

LoginRateLimit int

FilesRateLimit int

MetricsCacheRefreshInterval time.Duration

AgentStatsRefreshInterval time.Duration

DeploymentValues *codersdk.DeploymentValues

// DeploymentOptions do contain the copy of DeploymentValues, and contain

// contextual information about how the values were set.

// Do not use DeploymentOptions to retrieve values, use DeploymentValues instead.

// All secrets values are stripped.

DeploymentOptions serpent.OptionSet

UpdateCheckOptions *updatecheck.Options // Set non-nil to enable update checking.

// SSHConfig is the response clients use to configure config-ssh locally.

SSHConfig codersdk.SSHConfigResponse

HTTPClient *http.Client

// ChatSubscribeFn provides cross-replica subscription merging.

// Set by enterprise for HA deployments. Nil in AGPL single-replica.

ChatSubscribeFn chatd.SubscribeFn

UpdateAgentMetrics func(ctx context.Context, labels prometheusmetrics.AgentMetricLabels, metrics []*agentproto.Stats_Metric)

StatsBatcher workspacestats.Batcher

MetadataBatcherOptions []metadatabatcher.Option

ProvisionerdServerMetrics *provisionerdserver.Metrics

WorkspaceBuilderMetrics *wsbuilder.Metrics

// WorkspaceAppAuditSessionTimeout allows changing the timeout for audit

// sessions. Raising or lowering this value will directly affect the write

// load of the audit log table. This is used for testing. Default 1 hour.

WorkspaceAppAuditSessionTimeout time.Duration

WorkspaceAppsStatsCollectorOptions workspaceapps.StatsCollectorOptions

// This janky function is used in telemetry to parse fields out of the raw

// JWT. It needs to be passed through like this because license parsing is

// under the enterprise license, and can't be imported into AGPL.

ParseLicenseClaims func(rawJWT string) (email string, trial bool, err error)

AllowWorkspaceRenames bool

// NewTicker is used for unit tests to replace "time.NewTicker".

NewTicker func(duration time.Duration) (tick <-chan time.Time, done func())

// DatabaseRolluper rolls up template usage stats from raw agent and app

// stats. This is used to provide insights in the WebUI.

DatabaseRolluper *dbrollup.Rolluper

// WorkspaceUsageTracker tracks workspace usage by the CLI.

WorkspaceUsageTracker *workspacestats.UsageTracker

// BoundaryUsageTracker tracks boundary usage for telemetry.

BoundaryUsageTracker *boundaryusage.Tracker

// NotificationsEnqueuer handles enqueueing notifications for delivery by SMTP, webhook, etc.

NotificationsEnqueuer notifications.Enqueuer

// IDPSync holds all configured values for syncing external IDP users into Coder.

IDPSync idpsync.IDPSync

// OneTimePasscodeValidityPeriod specifies how long a one time passcode should be valid for.

OneTimePasscodeValidityPeriod time.Duration

// Keycaches

AppSigningKeyCache cryptokeys.SigningKeycache

AppEncryptionKeyCache cryptokeys.EncryptionKeycache

OIDCConvertKeyCache cryptokeys.SigningKeycache

Clock quartz.Clock

// WebPushDispatcher is a way to send notifications over Web Push.

WebPushDispatcher webpush.Dispatcher

}

// @title Coder API

// @version 2.0

// @description Coderd is the service created by running coder server. It is a thin API that connects workspaces, provisioners and users. coderd stores its state in Postgres and is the only service that communicates with Postgres.

// @termsOfService https://coder.com/legal/terms-of-service

// @contact.name API Support

// @contact.url https://coder.com

// @contact.email support@coder.com

// @license.name AGPL-3.0

// @license.url https://github.com/coder/coder/blob/main/LICENSE

// @BasePath /api/v2

// @securitydefinitions.apiKey Authorization

// @in header

// @name Authorizaiton

// @securitydefinitions.apiKey CoderSessionToken

// @in header

// @name Coder-Session-Token

// New constructs a Coder API handler.

func New(options *Options) *API {

if options == nil {

options = &Options{}

}

if options.Entitlements == nil {

options.Entitlements = entitlements.New()

}

if options.NewTicker == nil {

options.NewTicker = func(duration time.Duration) (tick <-chan time.Time, done func()) {

ticker := time.NewTicker(duration)

return ticker.C, ticker.Stop

}

}

// Safety check: if we're not running a unit test, we *must* have a Prometheus registry.

if options.PrometheusRegistry == nil && flag.Lookup("test.v") == nil {

panic("developer error: options.PrometheusRegistry is nil and not running a unit test")

}

if options.DeploymentValues.DisableOwnerWorkspaceExec || options.DeploymentValues.DisableWorkspaceSharing {

rbac.ReloadBuiltinRoles(&rbac.RoleOptions{

NoOwnerWorkspaceExec: bool(options.DeploymentValues.DisableOwnerWorkspaceExec),

NoWorkspaceSharing: bool(options.DeploymentValues.DisableWorkspaceSharing),

})

}

if options.DeploymentValues.DisableWorkspaceSharing {

rbac.SetWorkspaceACLDisabled(true)

}

if options.PrometheusRegistry == nil {

options.PrometheusRegistry = prometheus.NewRegistry()

options.PrometheusRegistry.MustRegister(collectors.NewGoCollector())

}

if options.Authorizer == nil {

options.Authorizer = rbac.NewCachingAuthorizer(options.PrometheusRegistry)

if buildinfo.IsDev() {

options.Authorizer = rbac.Recorder(options.Authorizer)

}

}

if options.AccessControlStore == nil {

options.AccessControlStore = &atomic.Pointer[dbauthz.AccessControlStore]{}

var tacs dbauthz.AccessControlStore = dbauthz.AGPLTemplateAccessControlStore{}

options.AccessControlStore.Store(&tacs)

}

options.Database = dbauthz.New(

options.Database,

options.Authorizer,

options.Logger.Named("authz_querier"),

options.AccessControlStore,

)

if options.IDPSync == nil {

options.IDPSync = idpsync.NewAGPLSync(options.Logger, options.RuntimeConfig, idpsync.FromDeploymentValues(options.DeploymentValues))

}

experiments := ReadExperiments(

options.Logger, options.DeploymentValues.Experiments.Value(),

)

if options.AppHostname != "" && options.AppHostnameRegex == nil || options.AppHostname == "" && options.AppHostnameRegex != nil {

panic("coderd: both AppHostname and AppHostnameRegex must be set or unset")

}

if options.AgentConnectionUpdateFrequency == 0 {

options.AgentConnectionUpdateFrequency = 15 * time.Second

}

if options.AgentInactiveDisconnectTimeout == 0 {

// Multiply the update by two to allow for some lag-time.

options.AgentInactiveDisconnectTimeout = options.AgentConnectionUpdateFrequency * 2

// Set a minimum timeout to avoid disconnecting too soon.

if options.AgentInactiveDisconnectTimeout < 2*time.Second {

options.AgentInactiveDisconnectTimeout = 2 * time.Second

}

}

if options.AgentStatsRefreshInterval == 0 {

options.AgentStatsRefreshInterval = 5 * time.Minute

}

if options.MetricsCacheRefreshInterval == 0 {

options.MetricsCacheRefreshInterval = time.Hour

}

if options.APIRateLimit == 0 {

options.APIRateLimit = 512

}

if options.LoginRateLimit == 0 {

options.LoginRateLimit = 60

}

if options.FilesRateLimit == 0 {

options.FilesRateLimit = 12

}

if options.Clock == nil {

options.Clock = quartz.NewReal()

}

if options.DERPServer == nil && options.DeploymentValues.DERP.Server.Enable {

options.DERPServer = derp.NewServer(key.NewNode(), tailnet.Logger(options.Logger.Named("derp")))

}

if options.DERPMapUpdateFrequency == 0 {

options.DERPMapUpdateFrequency = 5 * time.Second

}

if options.NetworkTelemetryBatchFrequency == 0 {

options.NetworkTelemetryBatchFrequency = 1 * time.Minute

}

if options.NetworkTelemetryBatchMaxSize == 0 {

options.NetworkTelemetryBatchMaxSize = 1_000

}

if options.TailnetCoordinator == nil {

options.TailnetCoordinator = tailnet.NewCoordinator(options.Logger)

}

if options.Auditor == nil {

options.Auditor = audit.NewNop()

}

if options.ConnectionLogger == nil {

options.ConnectionLogger = connectionlog.NewNop()

}

if options.SSHConfig.HostnamePrefix == "" {

options.SSHConfig.HostnamePrefix = "coder."

}

if options.TracerProvider == nil {

options.TracerProvider = trace.NewNoopTracerProvider()

}

if options.TemplateScheduleStore == nil {

options.TemplateScheduleStore = &atomic.Pointer[schedule.TemplateScheduleStore]{}

}

if options.TemplateScheduleStore.Load() == nil {

v := schedule.NewAGPLTemplateScheduleStore()

options.TemplateScheduleStore.Store(&v)

}

if options.UserQuietHoursScheduleStore == nil {

options.UserQuietHoursScheduleStore = &atomic.Pointer[schedule.UserQuietHoursScheduleStore]{}

}

if options.UserQuietHoursScheduleStore.Load() == nil {

v := schedule.NewAGPLUserQuietHoursScheduleStore()

options.UserQuietHoursScheduleStore.Store(&v)

}

if options.UsageInserter == nil {

options.UsageInserter = &atomic.Pointer[usage.Inserter]{}

}

if options.UsageInserter.Load() == nil {

inserter := usage.NewAGPLInserter()

options.UsageInserter.Store(&inserter)

}

if options.OneTimePasscodeValidityPeriod == 0 {

options.OneTimePasscodeValidityPeriod = 20 * time.Minute

}

if options.StatsBatcher == nil {

panic("developer error: options.StatsBatcher is nil")

}

siteCacheDir := options.CacheDir

if siteCacheDir != "" {

siteCacheDir = filepath.Join(siteCacheDir, "site")

}

metricsCache := metricscache.New(

options.Database,

options.Logger.Named("metrics_cache"),

quartz.NewReal(),

metricscache.Intervals{

TemplateBuildTimes: options.MetricsCacheRefreshInterval,

DeploymentStats: options.AgentStatsRefreshInterval,

},

experiments.Enabled(codersdk.ExperimentWorkspaceUsage),

)

oauthConfigs := &httpmw.OAuth2Configs{

Github: options.GithubOAuth2Config,

OIDC: options.OIDCConfig,

}

if options.DatabaseRolluper == nil {

options.DatabaseRolluper = dbrollup.New(options.Logger.Named("dbrollup"), options.Database)

}

if options.WorkspaceUsageTracker == nil {

options.WorkspaceUsageTracker = workspacestats.NewTracker(options.Database,

workspacestats.TrackerWithLogger(options.Logger.Named("workspace_usage_tracker")),

)

}

if options.NotificationsEnqueuer == nil {

options.NotificationsEnqueuer = notifications.NewNoopEnqueuer()

}

r := chi.NewRouter()

// We add this middleware early, to make sure that authorization checks made

// by other middleware get recorded.

if buildinfo.IsDev() {

r.Use(httpmw.RecordAuthzChecks(options.DeploymentValues.EnableAuthzRecording.Value()))

}

ctx, cancel := context.WithCancel(context.Background())

// nolint:gocritic // Load deployment ID. This never changes

depID, err := options.Database.GetDeploymentID(dbauthz.AsSystemRestricted(ctx))

if err != nil {

panic(xerrors.Errorf("get deployment ID: %w", err))

}

fetcher := &cryptokeys.DBFetcher{

DB: options.Database,

}

if options.OIDCConvertKeyCache == nil {

options.OIDCConvertKeyCache, err = cryptokeys.NewSigningCache(ctx,

options.Logger.Named("oidc_convert_keycache"),

fetcher,

codersdk.CryptoKeyFeatureOIDCConvert,

)

if err != nil {

options.Logger.Fatal(ctx, "failed to properly instantiate oidc convert signing cache", slog.Error(err))

}

}

if options.AppSigningKeyCache == nil {

options.AppSigningKeyCache, err = cryptokeys.NewSigningCache(ctx,

options.Logger.Named("app_signing_keycache"),

fetcher,

codersdk.CryptoKeyFeatureWorkspaceAppsToken,

)

if err != nil {

options.Logger.Fatal(ctx, "failed to properly instantiate app signing key cache", slog.Error(err))

}

}

if options.AppEncryptionKeyCache == nil {

options.AppEncryptionKeyCache, err = cryptokeys.NewEncryptionCache(ctx,

options.Logger,

fetcher,

codersdk.CryptoKeyFeatureWorkspaceAppsAPIKey,

)

if err != nil {

options.Logger.Fatal(ctx, "failed to properly instantiate app encryption key cache", slog.Error(err))

}

}

if options.CoordinatorResumeTokenProvider == nil {

fetcher := &cryptokeys.DBFetcher{

DB: options.Database,

}

resumeKeycache, err := cryptokeys.NewSigningCache(ctx,

options.Logger,

fetcher,

codersdk.CryptoKeyFeatureTailnetResume,

)

if err != nil {

options.Logger.Fatal(ctx, "failed to properly instantiate tailnet resume signing cache", slog.Error(err))

}

options.CoordinatorResumeTokenProvider = tailnet.NewResumeTokenKeyProvider(

resumeKeycache,

options.Clock,

tailnet.DefaultResumeTokenExpiry,

)

}

updatesProvider := NewUpdatesProvider(options.Logger.Named("workspace_updates"), options.Pubsub, options.Database, options.Authorizer)

// Start a background process that rotates keys. We intentionally start this after the caches

// are created to force initial requests for a key to populate the caches. This helps catch

// bugs that may only occur when a key isn't precached in tests and the latency cost is minimal.

cryptokeys.StartRotator(ctx, options.Logger, options.Database)

// Ensure all system role permissions are current.

//nolint:gocritic // Startup reconciliation reads/writes system roles. There is

// no user request context here, so use a system-restricted context.

err = rolestore.ReconcileSystemRoles(dbauthz.AsSystemRestricted(ctx), options.Logger, options.Database)

if err != nil {

// Not ideal, but not using Fatal here and just continuing

// after logging the error would be a potential security hole.

options.Logger.Fatal(ctx, "failed to reconcile system role permissions", slog.Error(err))

}

// AGPL uses a no-op build usage checker as there are no license

// entitlements to enforce. This is swapped out in

// enterprise/coderd/coderd.go.

var buildUsageChecker atomic.Pointer[wsbuilder.UsageChecker]

var noopUsageChecker wsbuilder.UsageChecker = wsbuilder.NoopUsageChecker{}

buildUsageChecker.Store(&noopUsageChecker)

api := &API{

ctx: ctx,

cancel: cancel,

DeploymentID: depID,

ID: uuid.New(),

Options: options,

RootHandler: r,

HTTPAuth: &HTTPAuthorizer{

Authorizer: options.Authorizer,

Logger: options.Logger,

},

metricsCache: metricsCache,

Auditor: atomic.Pointer[audit.Auditor]{},

ConnectionLogger: atomic.Pointer[connectionlog.ConnectionLogger]{},

TailnetCoordinator: atomic.Pointer[tailnet.Coordinator]{},

UpdatesProvider: updatesProvider,

TemplateScheduleStore: options.TemplateScheduleStore,

UserQuietHoursScheduleStore: options.UserQuietHoursScheduleStore,

AccessControlStore: options.AccessControlStore,

BuildUsageChecker: &buildUsageChecker,

UsageInserter: options.UsageInserter,

FileCache: files.New(options.PrometheusRegistry, options.Authorizer),

Experiments: experiments,

WebpushDispatcher: options.WebPushDispatcher,

healthCheckGroup: &singleflight.Group[string, *healthsdk.HealthcheckReport]{},

Acquirer: provisionerdserver.NewAcquirer(

ctx,

options.Logger.Named("acquirer"),

options.Database,

options.Pubsub,

),

dbRolluper: options.DatabaseRolluper,

ProfileCollector: defaultProfileCollector{},

AISeatTracker: aiseats.Noop{},

}

api.WorkspaceAppsProvider = workspaceapps.NewDBTokenProvider(

ctx,

options.Logger.Named("workspaceapps"),

options.AccessURL,

options.Authorizer,

&api.ConnectionLogger,

options.Database,

options.DeploymentValues,

oauthConfigs,

options.AgentInactiveDisconnectTimeout,

options.WorkspaceAppAuditSessionTimeout,

options.AppSigningKeyCache,

)

f := appearance.NewDefaultFetcher(api.DeploymentValues.DocsURL.String())

api.AppearanceFetcher.Store(&f)

api.PortSharer.Store(&portsharing.DefaultPortSharer)

api.PrebuildsClaimer.Store(&prebuilds.DefaultClaimer)

api.PrebuildsReconciler.Store(&prebuilds.DefaultReconciler)

buildInfo := codersdk.BuildInfoResponse{

ExternalURL: buildinfo.ExternalURL(),

Version: buildinfo.Version(),

AgentAPIVersion: AgentAPIVersionREST,

ProvisionerAPIVersion: proto.CurrentVersion.String(),

DashboardURL: api.AccessURL.String(),

WorkspaceProxy: false,

UpgradeMessage: api.DeploymentValues.CLIUpgradeMessage.String(),

DeploymentID: api.DeploymentID,

WebPushPublicKey: api.WebpushDispatcher.PublicKey(),

Telemetry: api.Telemetry.Enabled(),

}

api.SiteHandler, err = site.New(&site.Options{

CacheDir: siteCacheDir,

Database: options.Database,

Authorizer: options.Authorizer,

SiteFS: site.FS(),

OAuth2Configs: oauthConfigs,

DocsURL: options.DeploymentValues.DocsURL.String(),

AppearanceFetcher: &api.AppearanceFetcher,

BuildInfo: buildInfo,

Entitlements: options.Entitlements,

Telemetry: options.Telemetry,

Logger: options.Logger.Named("site"),

HideAITasks: options.DeploymentValues.HideAITasks.Value(),

})

if err != nil {

options.Logger.Fatal(ctx, "failed to initialize site handler", slog.Error(err))

}

api.SiteHandler.Experiments.Store(&experiments)

if options.UpdateCheckOptions != nil {

api.updateChecker = updatecheck.New(

options.Database,

options.Logger.Named("update_checker"),

*options.UpdateCheckOptions,

)

}

if options.WorkspaceProxiesFetchUpdater == nil {

options.WorkspaceProxiesFetchUpdater = &atomic.Pointer[healthcheck.WorkspaceProxiesFetchUpdater]{}

var wpfu healthcheck.WorkspaceProxiesFetchUpdater = &healthcheck.AGPLWorkspaceProxiesFetchUpdater{}

options.WorkspaceProxiesFetchUpdater.Store(&wpfu)

}

if options.HealthcheckFunc == nil {

options.HealthcheckFunc = func(ctx context.Context, apiKey string, progress *healthcheck.Progress) *healthsdk.HealthcheckReport {

// NOTE: dismissed healthchecks are marked in formatHealthcheck.

// Not here, as this result gets cached.

return healthcheck.Run(ctx, &healthcheck.ReportOptions{

Database: healthcheck.DatabaseReportOptions{

DB: options.Database,

Threshold: options.DeploymentValues.Healthcheck.ThresholdDatabase.Value(),

},

Websocket: healthcheck.WebsocketReportOptions{

AccessURL: options.AccessURL,

APIKey: apiKey,

},

AccessURL: healthcheck.AccessURLReportOptions{

AccessURL: options.AccessURL,

},

DerpHealth: derphealth.ReportOptions{

DERPMap: api.DERPMap(),

},

WorkspaceProxy: healthcheck.WorkspaceProxyReportOptions{

WorkspaceProxiesFetchUpdater: *(options.WorkspaceProxiesFetchUpdater).Load(),

},

ProvisionerDaemons: healthcheck.ProvisionerDaemonsReportDeps{

CurrentVersion: buildinfo.Version(),

CurrentAPIMajorVersion: proto.CurrentMajor,

Store: options.Database,

StaleInterval: provisionerdserver.StaleInterval,

// TimeNow set to default, see healthcheck/provisioner.go

},

Progress: progress,

})

}

}

if options.HealthcheckTimeout == 0 {

options.HealthcheckTimeout = 30 * time.Second

}

if options.HealthcheckRefresh == 0 {

options.HealthcheckRefresh = options.DeploymentValues.Healthcheck.Refresh.Value()

}

var oidcAuthURLParams map[string]string

if options.OIDCConfig != nil {

oidcAuthURLParams = options.OIDCConfig.AuthURLParams

}

api.Auditor.Store(&options.Auditor)

api.ConnectionLogger.Store(&options.ConnectionLogger)

api.TailnetCoordinator.Store(&options.TailnetCoordinator)

dialer := &InmemTailnetDialer{

CoordPtr: &api.TailnetCoordinator,

DERPFn: api.DERPMap,

Logger: options.Logger,

ClientID: uuid.New(),

DatabaseHealthCheck: api.Database,

}

stn, err := NewServerTailnet(api.ctx,

options.Logger,

options.DERPServer,

dialer,

options.DeploymentValues.DERP.Config.ForceWebSockets.Value(),

options.DeploymentValues.DERP.Config.BlockDirect.Value(),

api.TracerProvider,

)

if err != nil {

panic("failed to setup server tailnet: " + err.Error())

}

api.agentProvider = stn

maxChatsPerAcquire := options.DeploymentValues.AI.Chat.AcquireBatchSize.Value()

if maxChatsPerAcquire > math.MaxInt32 {

maxChatsPerAcquire = math.MaxInt32

}

if maxChatsPerAcquire < math.MinInt32 {

maxChatsPerAcquire = math.MinInt32

}

api.chatDaemon = chatd.New(chatd.Config{

Logger: options.Logger.Named("chatd"),

Database: options.Database,

ReplicaID: api.ID,

SubscribeFn: options.ChatSubscribeFn,

MaxChatsPerAcquire: int32(maxChatsPerAcquire), //nolint:gosec // maxChatsPerAcquire is clamped to int32 range above.

ProviderAPIKeys: chatProviderAPIKeysFromDeploymentValues(options.DeploymentValues),

AgentConn: api.agentProvider.AgentConn,

CreateWorkspace: api.chatCreateWorkspace,

StartWorkspace: api.chatStartWorkspace,

Pubsub: options.Pubsub,

WebpushDispatcher: options.WebPushDispatcher,

UsageTracker: options.WorkspaceUsageTracker,

})

gitSyncLogger := options.Logger.Named("gitsync")

refresher := gitsync.NewRefresher(

api.resolveGitProvider,

api.resolveChatGitAccessToken,

gitSyncLogger.Named("refresher"),

quartz.NewReal(),

)

api.gitSyncWorker = gitsync.NewWorker(options.Database,

refresher,

api.chatDaemon.PublishDiffStatusChange,

quartz.NewReal(),

gitSyncLogger,

)

// nolint:gocritic // chat diff worker needs to be able to CRUD chats.

go api.gitSyncWorker.Start(dbauthz.AsChatd(api.ctx))

if options.DeploymentValues.Prometheus.Enable {

options.PrometheusRegistry.MustRegister(stn)

api.lifecycleMetrics = agentapi.NewLifecycleMetrics(options.PrometheusRegistry)

}

api.NetworkTelemetryBatcher = tailnet.NewNetworkTelemetryBatcher(

quartz.NewReal(),

api.Options.NetworkTelemetryBatchFrequency,

api.Options.NetworkTelemetryBatchMaxSize,

api.handleNetworkTelemetry,

)

if options.CoordinatorResumeTokenProvider == nil {

panic("CoordinatorResumeTokenProvider is nil")

}

api.TailnetClientService, err = tailnet.NewClientService(tailnet.ClientServiceOptions{

Logger: api.Logger.Named("tailnetclient"),

CoordPtr: &api.TailnetCoordinator,

DERPMapUpdateFrequency: api.Options.DERPMapUpdateFrequency,

DERPMapFn: api.DERPMap,

NetworkTelemetryHandler: api.NetworkTelemetryBatcher.Handler,

ResumeTokenProvider: api.Options.CoordinatorResumeTokenProvider,

WorkspaceUpdatesProvider: api.UpdatesProvider,

})

if err != nil {

api.Logger.Fatal(context.Background(), "failed to initialize tailnet client service", slog.Error(err))

}

api.statsReporter = workspacestats.NewReporter(workspacestats.ReporterOptions{

Database: options.Database,

Logger: options.Logger.Named("workspacestats"),

Pubsub: options.Pubsub,

TemplateScheduleStore: options.TemplateScheduleStore,

StatsBatcher: options.StatsBatcher,

UsageTracker: options.WorkspaceUsageTracker,

UpdateAgentMetricsFn: options.UpdateAgentMetrics,

AppStatBatchSize: workspaceapps.DefaultStatsDBReporterBatchSize,

DisableDatabaseInserts: !options.DeploymentValues.StatsCollection.UsageStats.Enable.Value(),

})

// Initialize the metadata batcher for batching agent metadata updates.

batcherOpts := []metadatabatcher.Option{

metadatabatcher.WithLogger(options.Logger.Named("metadata_batcher")),

}

batcherOpts = append(batcherOpts, options.MetadataBatcherOptions...)

api.metadataBatcher, err = metadatabatcher.NewBatcher(

api.ctx,

options.PrometheusRegistry,

options.Database,

options.Pubsub,

batcherOpts...,

)

if err != nil {

api.Logger.Fatal(context.Background(), "failed to initialize metadata batcher", slog.Error(err))

}

workspaceAppsLogger := options.Logger.Named("workspaceapps")

if options.WorkspaceAppsStatsCollectorOptions.Logger == nil {

named := workspaceAppsLogger.Named("stats_collector")

options.WorkspaceAppsStatsCollectorOptions.Logger = &named

}

if options.WorkspaceAppsStatsCollectorOptions.Reporter == nil {

options.WorkspaceAppsStatsCollectorOptions.Reporter = api.statsReporter

}

api.workspaceAppServer = workspaceapps.NewServer(workspaceapps.ServerOptions{

Logger: workspaceAppsLogger,

DashboardURL: api.AccessURL,

AccessURL: api.AccessURL,

Hostname: api.AppHostname,

HostnameRegex: api.AppHostnameRegex,

RealIPConfig: options.RealIPConfig,

SignedTokenProvider: api.WorkspaceAppsProvider,

AgentProvider: api.agentProvider,

StatsCollector: workspaceapps.NewStatsCollector(options.WorkspaceAppsStatsCollectorOptions),

DisablePathApps: options.DeploymentValues.DisablePathApps.Value(),

CookiesConfig: options.DeploymentValues.HTTPCookies,

APIKeyEncryptionKeycache: options.AppEncryptionKeyCache,

})

apiKeyMiddleware := httpmw.ExtractAPIKeyMW(httpmw.ExtractAPIKeyConfig{

DB: options.Database,

ActivateDormantUser: ActivateDormantUser(options.Logger, &api.Auditor, options.Database),

OAuth2Configs: oauthConfigs,

RedirectToLogin: false,

DisableSessionExpiryRefresh: options.DeploymentValues.Sessions.DisableExpiryRefresh.Value(),

Optional: false,

SessionTokenFunc: nil, // Default behavior

PostAuthAdditionalHeadersFunc: options.PostAuthAdditionalHeadersFunc,

Logger: options.Logger,

AccessURL: options.AccessURL,

})

// Same as above but it redirects to the login page.

apiKeyMiddlewareRedirect := httpmw.ExtractAPIKeyMW(httpmw.ExtractAPIKeyConfig{

DB: options.Database,

OAuth2Configs: oauthConfigs,

RedirectToLogin: true,

DisableSessionExpiryRefresh: options.DeploymentValues.Sessions.DisableExpiryRefresh.Value(),

Optional: false,

SessionTokenFunc: nil, // Default behavior

PostAuthAdditionalHeadersFunc: options.PostAuthAdditionalHeadersFunc,

Logger: options.Logger,

AccessURL: options.AccessURL,

})

// Same as the first but it's optional.

apiKeyMiddlewareOptional := httpmw.ExtractAPIKeyMW(httpmw.ExtractAPIKeyConfig{

DB: options.Database,

OAuth2Configs: oauthConfigs,

RedirectToLogin: false,

DisableSessionExpiryRefresh: options.DeploymentValues.Sessions.DisableExpiryRefresh.Value(),

Optional: true,

SessionTokenFunc: nil, // Default behavior

PostAuthAdditionalHeadersFunc: options.PostAuthAdditionalHeadersFunc,

Logger: options.Logger,

AccessURL: options.AccessURL,

})

workspaceAgentInfo := httpmw.ExtractWorkspaceAgentAndLatestBuild(httpmw.ExtractWorkspaceAgentAndLatestBuildConfig{

DB: options.Database,

Optional: false,

})

// API rate limit middleware. The counter is local and not shared between

// replicas or instances of this middleware.

apiRateLimiter := httpmw.RateLimit(options.APIRateLimit, time.Minute)

// Register DERP on expvar HTTP handler, which we serve below in the router, c.f. expvar.Handler()

expDERPOnce.Do(func() {

// We need to do this via a global Once because expvar registry is global and panics if we

// register multiple times. In production there is only one Coderd and one DERP server per

// process, but in testing, we create multiple of both, so the Once protects us from

// panicking.

if options.DERPServer != nil && expvar.Get("derp") == nil {

expvar.Publish("derp", api.DERPServer.ExpVar())

}

})

if options.PrometheusRegistry != nil && options.DERPServer != nil {

options.PrometheusRegistry.MustRegister(derpmetrics.NewDERPExpvarCollector(options.DERPServer))

}

cors := httpmw.Cors(options.DeploymentValues.Dangerous.AllowAllCors.Value())

prometheusMW := httpmw.Prometheus(options.PrometheusRegistry)

r.Use(

sharedhttpmw.Recover(api.Logger),

httpmw.WithProfilingLabels,

tracing.StatusWriterMiddleware,

options.DeploymentValues.HTTPCookies.Middleware,

tracing.Middleware(api.TracerProvider),

httpmw.AttachRequestID,

httpmw.ExtractRealIP(api.RealIPConfig),

loggermw.Logger(api.Logger),

singleSlashMW,

rolestore.CustomRoleMW,

// Validate API key on every request (if present) and store

// the result in context. The rate limiter reads this to key

// by user ID, and downstream ExtractAPIKeyMW reuses it to

// avoid redundant DB lookups. Never rejects requests.

httpmw.PrecheckAPIKey(httpmw.ValidateAPIKeyConfig{

DB: options.Database,

OAuth2Configs: oauthConfigs,

DisableSessionExpiryRefresh: options.DeploymentValues.Sessions.DisableExpiryRefresh.Value(),

Logger: options.Logger,

}),

httpmw.HTTPRoute, // NB: prometheusMW depends on this middleware.

prometheusMW,

// Build-Version is helpful for debugging.

func(next http.Handler) http.Handler {

return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {

w.Header().Add(codersdk.BuildVersionHeader, buildinfo.Version())

next.ServeHTTP(w, r)

})

},

// SubdomainAppMW checks if the first subdomain is a valid app URL. If

// it is, it will serve that application.

//

// Workspace apps do their own auth and CORS and must be BEFORE the auth

// and CORS middleware.

api.workspaceAppServer.HandleSubdomain(apiRateLimiter),

cors,

// This header stops a browser from trying to MIME-sniff the content type and

// forces it to stick with the declared content-type. This is the only valid

// value for this header.

// See: https://github.com/coder/security/issues/12

func(next http.Handler) http.Handler {

return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {

w.Header().Add("X-Content-Type-Options", "nosniff")

next.ServeHTTP(w, r)

})

},

httpmw.CSRF(options.DeploymentValues.HTTPCookies),

)

// This incurs a performance hit from the middleware, but is required to make sure