web

type Authorizer interface {
	StartLogin(pipeline *Pipeline, server string, req LoginRequest) (LoginStatus, error)
	LoginStatus(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 LocalRunner struct {
	// contains filtered or unexported fields
}

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 by server NAME and a second Connect replaces the first under it. Without it a request can only ask "what is the state of the 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"`
	TokenPath string `json:"token_path,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. 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 {
	// Slug is the name `steps pipeline set` was given: the route, the store's pipelines.name and the Config's name are ONE identity, not three kept in agreement.
	Slug string

	Store store.Store
	// Bus carries live run events for runs this process itself executes.
	// Runs started by a separate `steps run` land in the store but not on
	// this bus, which is why every live view falls back to replaying the
	// stored events rather than assuming the bus saw everything.
	Bus *events.Bus
	// 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, the division that keeps the runner an interface. 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"`
}

type PlacementView struct {
	store.Placement
}

type Runner interface {
	// Enqueue queues a job for execution, returning the queue row id.
	Enqueue(ctx context.Context, pipeline *Pipeline, jobName, reason string, force bool) (int64, error)
	// Abort cancels a run this process is executing, and reports false when it is not running here.
	Abort(pipeline *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 *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"`
}

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"`
}