mcpserver

type Caller struct {
	// Login is the person's GitHub login.
	Login string
	// ID is the person's GitHub user id, stable across a renamed login.
	ID int64
}

type Checkouts interface {
	// Clone checks out main of repository, owner/repo, into a new directory,
	// fetching and pushing with token and committing as author. remove
	// deletes the directory; the call runs it when it ends.
	Clone(ctx context.Context, repository, token string, author Caller) (dir string, remove func(), err error)
}

type Clusters interface {
	// Open is the client of installation's management cluster acting as the
	// caller in ctx, its requests going through wrap: auth_required without
	// the person's token, not_applicable for an installation the server does
	// not reach.
	Open(ctx context.Context, installation string, wrap func(http.RoundTripper) http.RoundTripper) (dynamic.Interface, error)
	// Installations are the names of the installations it reaches.
	Installations() []string
}

type Config struct {
	// Version is the version the server reports: the binary's.
	Version string
	// Credentials answer the person's GitHub token; nil is [NoCredentials].
	Credentials Credentials
	// Clusters open an installation's management cluster as the person;
	// nil is [NoClusters].
	Clusters Clusters
	// Sources build the clients a wait reads with; nil is [GitHubSources]
	// over Endpoints.
	Sources Sources
	// Endpoints are GitHub's and the registries'; zero is
	// [agentcli.DefaultEndpoints].
	Endpoints agentcli.Endpoints
	// Clock is the waits' clock; nil is the wall clock at scale 1, never
	// DEVCTL_TIME_SCALE.
	Clock *agentcli.Clock
	// ProgressInterval is how often a wait reports progress; zero is
	// DefaultProgressInterval.
	ProgressInterval time.Duration
	// NoProgressTimeout bounds a wait called without a progressToken, so
	// it answers within the gateway's registered timeout; zero is
	// DefaultNoProgressTimeout.
	NoProgressTimeout time.Duration
	// Checkouts clone the GitOps repository of a reservation call; nil is
	// [GitCheckouts] from GitHub into the system's temporary directory.
	Checkouts Checkouts
	// Merges are the merges of this server pr_merge_status reads; nil is an
	// empty [mergejob.Memory]. pr_merge records its merges in them when they
	// take a Put, as a Memory does. Nothing is kept on disk.
	Merges mergejob.Jobs
	// ReleasePromote serves release_promote, the selector of the one tool
	// that cuts a stable release; off, the tool is not listed.
	ReleasePromote bool
	// Metrics count the calls; nil counts none.
	Metrics *Metrics
	// Logger logs one line per call; nil logs nothing.
	Logger *slog.Logger
}

type Credentials interface {
	// GitHubToken is the person's token for the call in ctx; an
	// [agentcli.ExitCoder] of [agentcli.ExitAuthRequired] when the server
	// holds none for them.
	GitHubToken(ctx context.Context) (string, error)
}

type Dex struct {
	// TokenEndpoint is Dex's token endpoint, https.
	TokenEndpoint string `json:"tokenEndpoint"`
	// Issuer is the issuer the exchanged token must name; empty is the
	// token endpoint without /token.
	Issuer string `json:"issuer,omitempty"`
	// ConnectorID is the connector of Dex that trusts the hub's Dex, which
	// issued the person's token.
	ConnectorID string `json:"connectorId"`
	// Audience is the client the API server accepts tokens of, asked for
	// as a cross-client audience; empty is dex-k8s-authenticator.
	Audience string `json:"audience,omitempty"`
	// ClientIDFile and ClientSecretFile hold the client the exchange
	// authenticates as, read when the server starts; without
	// ClientSecretFile the client is a public one.
	ClientIDFile     string `json:"clientIdFile"`
	ClientSecretFile string `json:"clientSecretFile,omitempty"`
}

type DexExchange struct {
	// Client sends the exchanges; nil is http.DefaultClient.
	Client *http.Client
	// Now is the clock of the exchanged tokens' expiry; nil is time.Now.
	Now func() time.Time
	// contains filtered or unexported fields
}

type GitCheckouts struct {
	// BaseURL is the git host; empty is DefaultGitBaseURL.
	BaseURL string
	// Dir holds the clones; empty is the system's temporary directory.
	Dir string
}

type GitHubInstallations struct {
	BaseURL string
	Client  *http.Client
	TTL     time.Duration
	Now     func() time.Time
	// contains filtered or unexported fields
}

type GitHubSources struct {
	Endpoints agentcli.Endpoints
}

type GitHubUsers struct {
	BaseURL string
	Client  *http.Client
	TTL     time.Duration
	Now     func() time.Time
	// contains filtered or unexported fields
}

type Installation struct {
	// Name is the installation's name, the tool's argument.
	Name string `json:"name"`
	// APIServer is the URL of the management cluster's Kubernetes API.
	APIServer string `json:"apiServer"`
	// CAFile is the API's certificate authority, PEM; empty trusts the
	// system's roots.
	CAFile string `json:"caFile,omitempty"`
	// Dex is the installation's Dex.
	Dex Dex `json:"dex"`
}

type Installations interface {
	Owners(ctx context.Context, token string) ([]string, error)
}

type Metrics struct {
	// contains filtered or unexported fields
}

type MusterGrant struct {
	// App is the provider App's name in muster, the header's suffix.
	App string
	// GitHubApp is the GitHub App's name, as a refusal names it.
	GitHubApp string
	// Users answer the person the token acts as, the call's caller; nil
	// names none and accepts the token unchecked.
	Users Users
	// Installations answer the owners the App is installed on that the
	// person reaches; nil checks none.
	Installations Installations
}

type NoClusters struct{}

type NoCredentials struct{}

type PRMergeSources struct {
	GitHub  prmerge.GitHub
	Rate    prwait.RateSource
	Entries prwait.EntryFinder
	// Policy is the repository's opt-out; nil reads the team files through
	// GitHub, a *githubclient.Client.
	Policy prmerge.Policy
}

type PRWaitSources struct {
	GitHub  prwait.GitHub
	Rate    prwait.RateSource
	Entries prwait.EntryFinder
}

type Server struct {
	// contains filtered or unexported fields
}

type Sources interface {
	PRWait(ctx context.Context, token string, transport http.RoundTripper) (PRWaitSources, error)
	PRMerge(ctx context.Context, token string, transport http.RoundTripper) (PRMergeSources, error)
	ReleaseWait(ctx context.Context, token string, transport http.RoundTripper) (*releasewait.Sources, error)
	ReleasePromote(ctx context.Context, token string, transport http.RoundTripper) (*releasepromote.Sources, error)
}

type Users interface {
	User(ctx context.Context, token string) (Caller, error)
}