web

type Authorizer interface {
	StartLogin(pipeline *Pipeline, server string, req LoginRequest) (LoginStatus, error)
	LoginStatus(pipeline *Pipeline, server string) (LoginStatus, bool)
	// LoginCallback is the handler for the pending login that minted state, nil when none did.
	LoginCallback(state string) http.Handler
	// MCPState is what the token-holder knows about one server: its saved credential, and the last probe anybody asked for. Never a request of its own — the page calls this on every poll.
	MCPState(pipeline *Pipeline, server string) MCPState
	// StartProbe connects to one server in the background, recording the result for MCPState to report. Refuses what it cannot honestly probe; a probe already in flight is left alone rather than duplicated.
	StartProbe(pipeline *Pipeline, server string) error
}

type BrokenPipeline struct {
	Name   string
	SHA    string
	From   string
	Reason string
}

type Capacity interface {
	RunCapacity() (limit, active int)
}

type Exporter interface {
	ServeExport(ctx context.Context, target *scheduler.Pipeline, export config.MCPExport, hooks scheduler.ExportHooks) (*scheduler.ExportServer, error)
}

type Identity struct {
	// Provider is where the name came from: local, github, google.
	Provider string
	// UserID is the name within it: a local account, a GitHub login, a Google address.
	UserID string
	// ID is the provider's own id for the account, which a rename does not change: GitHub's numeric user id, Google's subject, and for a local account its name. A rule that must not follow a renamed GitHub login onto whoever registers it next names this rather than UserID.
	ID            string
	Email         string
	Organizations []string
	Groups        []string
}

type LocalUser struct {
	Name string
	Hash []byte
}

type LoginRequest struct {
	Base string `json:"base"`
	// Return is where the browser is sent once the callback has answered, and it is a path on THIS daemon — refused otherwise (see redirectFor's sibling). Empty is a login a terminal is waiting on, which keeps the callback's plain "you can close this window": the CLI is the thing that reports the outcome there. A page sets it because the exchange finishes after the callback has answered, so the failure that matters most has nowhere else to land.
	Return string `json:"return,omitempty"`
}

type LoginStatus struct {
	State string `json:"state"`
	// ID names THIS attempt, because a login is tracked per pipeline and server and a second Connect replaces the first under that pair. Without it a request can only ask "what is the state of this pipeline's login called tracker", which after a replacement is somebody else's.
	ID string `json:"id,omitempty"`
	// AuthorizeURL appears once discovery and registration are done, which is network work the start request does not wait out.
	AuthorizeURL string `json:"authorize_url,omitempty"`
	// Message is the refusal, in the flow's own words — including the one that matters most unattended: authorized, but with a token that cannot be renewed.
	Message string `json:"message,omitempty"`
}

type MCPCredential struct {
	Connected bool
	// Detail is the sentence a reader acts on — "connected, renews automatically", "authorized for a different endpoint".
	Detail string
}

type MCPProbe struct {
	// Running is a probe still in flight, which the page's own poll will replace with its result.
	Running bool
	OK      bool
	Detail  string
	At      time.Time
	// Tools is what the server answered with, which is the question behind the question: a grant names a tool, and whether that name still exists is what a reader is really checking.
	Tools []string
}

type MCPState struct {
	Credential MCPCredential
	// Probe is the last Test of this server, nil when nobody has asked.
	Probe *MCPProbe
}

type Manager interface {
	// Set applies a configuration under name, creating the pipeline if this
	// daemon does not hold one. req.ExpectSHA is the revision the sender
	// diffed against: empty means "I did not look", and a mismatch is refused
	// rather than applied over whatever arrived in between.
	Set(ctx context.Context, name string, req SetRequest) (SetResult, error)
	Destroy(ctx context.Context, name string) error
	Rename(ctx context.Context, from, to string) error
}

type Option func(*Server)

type Pipeline struct {
	*scheduler.Pipeline

	// Hooks answers POST /p/<slug>/hooks/<resource>, a delivery to a webhook resource. Built by the caller (trigger.HookHandler): this package serves the surface and does not own the queue — internal/scheduler drains it, reached only through Runner. Nil only in a test.
	Hooks func(w http.ResponseWriter, r *http.Request, resource string)
	// contains filtered or unexported fields
}

type PipelineConfig struct {
	Name     string            `json:"name"`
	SHA      string            `json:"sha"`
	Source   string            `json:"source"`
	Includes map[string][]byte `json:"includes,omitempty"`
	From     string            `json:"from,omitempty"`
	Paused   bool              `json:"paused"`
}

type PipelineSummary struct {
	Name   string `json:"name"`
	SHA    string `json:"sha"`
	From   string `json:"from,omitempty"`
	Jobs   int    `json:"jobs"`
	Paused bool   `json:"paused"`
	// Broken is why a pipeline the daemon holds is not being served — a restart could not restore it — and empty for one that is.
	Broken string `json:"broken,omitempty"`
}

type PlacementView struct {
	store.Placement
}

type Role int

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

type Runner interface {
	// Enqueue queues a person's trigger of a job, returning the queue row id.
	Enqueue(ctx context.Context, pipeline *scheduler.Pipeline, jobName, reason string, force bool) (int64, error)
	// EnqueueRerun queues a retry of a recorded run.
	EnqueueRerun(ctx context.Context, pipeline *scheduler.Pipeline, jobName, runID string) error
	// Abort cancels a run this process is executing, and reports false when it is not running here.
	Abort(pipeline *scheduler.Pipeline, runID string) bool
	// AbortQueued drops a job's queued run before it starts, and reports false when nothing was queued.
	AbortQueued(ctx context.Context, pipeline *scheduler.Pipeline, jobName string) (bool, error)
}

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

type SetRequest struct {
	Source string `json:"source"`
	// A daemon has no sibling filesystem, so an include that does not travel here cannot be resolved at all (see config.Bundle); bytes rather than strings because encoding/json replaces each invalid UTF-8 byte of a string with U+FFFD, which ran a Latin-1 run_file: as bytes nobody sent.
	Includes map[string][]byte `json:"includes,omitempty"`
	// ExpectSHA is the compare-and-set. Empty means the sender did not look, which a script may legitimately do.
	ExpectSHA string `json:"expect_sha,omitempty"`
	// From is the SENDER's path, recorded for a reader wondering where a served configuration came from, and never opened here.
	From string `json:"from,omitempty"`
	// Pause is written with the revision, before the pipeline is started: a pause sent after the set is a second request, and the first poll — and whatever it triggers — can land between the two.
	Pause bool `json:"pause,omitempty"`
}

type SetResult struct {
	SHA string `json:"sha"`
	// Created, replaced and unchanged are three outcomes a person reads differently, so the answer says which.
	Created   bool `json:"created"`
	Unchanged bool `json:"unchanged"`
	// Repaired is a set that served a pipeline a restart had left broken.
	Repaired bool `json:"repaired,omitempty"`
}

type SignInProvider struct {
	// Name is the provider's word in URLs and in an actor's kind ("github").
	Name string
	// Label is what the sign-in button says it continues with.
	Label string
	// contains filtered or unexported fields
}