update

type ApplyRequest struct {
	Version     string    `json:"version"`
	RequestedBy string    `json:"requested_by"`
	RequestedAt time.Time `json:"requested_at"`
}

type ApplyResult struct {
	Version     string    `json:"version"`
	From        string    `json:"from,omitempty"`
	Outcome     string    `json:"outcome"`
	Message     string    `json:"message,omitempty"`
	RequestedBy string    `json:"requested_by,omitempty"`
	At          time.Time `json:"at"`
}

type Asset struct {
	Name string
	URL  string
	Size int64
}

type Auditor interface {
	Record(ctx context.Context, actor, event, target, detail string)
}

type Channel string

type Compat string

type Connected struct {
	Version string    `json:"version"`
	At      time.Time `json:"at"`
}

type Fetcher func(ctx context.Context, file string, w io.Writer) error

type GitHubSource struct {
	// Repo is "owner/name".
	Repo string
	// BaseURL is the API address; empty means https://api.github.com.
	BaseURL string
	// UserAgent identifies the hub to GitHub.
	UserAgent string
	Client    *http.Client
	// contains filtered or unexported fields
}

type Info struct {
	Version     string    `json:"version"`
	Tag         string    `json:"tag"`
	Prerelease  bool      `json:"prerelease"`
	Channel     Channel   `json:"channel"`
	URL         string    `json:"url"`
	Notes       string    `json:"notes,omitempty"`
	PublishedAt time.Time `json:"published_at"`
}

type Installer struct {
	// DataDir is the hub's data directory; the staged release and the request
	// are in it.
	DataDir string
	// StateDir belongs to root: the copy of the previous binary and the cache
	// of the signature trust root.
	StateDir string
	// Binary is the executable to replace, for example /usr/bin/regulus.
	Binary string
	// Unit is the service to restart, for example regulus.service.
	Unit string

	Verifier Verifier
	Run      Runner
	// Agent is true on a server that runs the agent: its health is that it
	// connected to the hub again (see WriteConnected), not the hub's local
	// status socket.
	Agent bool
	// Probe returns the version of the service that is running, or an error
	// while it is not up. Only a process that started at or after since counts:
	// the one that was there before the restart does not.
	Probe func(ctx context.Context, since time.Time) (string, error)

	// HealthTimeout is how long the new version has to come up; it must then
	// keep running for Stable. Poll is how often it is looked at.
	HealthTimeout, Stable, Poll time.Duration

	GOOS, GOARCH string
	Now          func() time.Time
	Log          *slog.Logger
}

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

type Mode string

type Options struct {
	DB     *sql.DB
	Log    *slog.Logger
	Source Source
	Stager *Stager
	Audit  Auditor
	// Version is the version the binary was built with.
	Version      string
	GOOS, GOARCH string
	// ApplyDir is the directory shared with the root helper (see ApplyDir);
	// empty when installing from the dashboard is turned off.
	ApplyDir string
	// Enabled is false when the hub must not contact the release server.
	Enabled    bool
	CheckEvery time.Duration
	// Now may be replaced in tests.
	Now func() time.Time
}

type Platform struct{ OS, Arch string }

type Release struct {
	Version     Version
	Tag         string
	URL         string // page of the release, for the release notes
	Notes       string
	PublishedAt time.Time
	Assets      []Asset
}

type Runner func(ctx context.Context, name string, args ...string) ([]byte, error)

type Settings struct {
	Mode    Mode    `json:"mode"`
	Channel Channel `json:"channel"`
	// WindowStart and WindowEnd ("15:04", the hub's local time) bound when the
	// automatic mode may install. They may cross midnight.
	WindowStart string `json:"window_start,omitempty"`
	WindowEnd   string `json:"window_end,omitempty"`
}

type SigstoreVerifier struct {
	// Trust provides the trusted root; nil uses PublicTrust with no cache.
	Trust TrustSource
	// Signer is the expected identity (the certificate's subject alternative
	// name) for a tag; nil expects the release workflow of this repository.
	Signer func(tag string) string
	// Issuer is the expected OIDC issuer; empty means GitHub Actions.
	Issuer string
	// contains filtered or unexported fields
}

type Source interface {
	Releases(ctx context.Context) ([]Release, error)
}

type Staged struct {
	Version  string    `json:"version"`
	Tag      string    `json:"tag"`
	Archive  string    `json:"archive"`
	SHA256   string    `json:"sha256"`
	Size     int64     `json:"size"`
	Verified string    `json:"verified"`
	StagedAt time.Time `json:"staged_at"`
	// Signed is true when the signature bundle of checksums.txt was published
	// and kept next to it. Verified says whether it was checked.
	Signed bool `json:"signed"`
}

type Stager struct {
	// Dir is the cache; it is created when needed.
	Dir    string
	Client *http.Client
	Now    func() time.Time
	// Verifier, if set, checks the signature of checksums.txt before anything
	// else is downloaded; a release without a valid signature is refused.
	Verifier Verifier
	// Keep, if set, is a version that is never pruned: the one this server runs,
	// whose files the hub serves to the agents it manages.
	Keep string
}

type Status struct {
	// CurrentVersion is the version of this hub as it was built.
	CurrentVersion string `json:"current_version"`
	// ReleaseBuild is false for a development build, which cannot compare
	// itself with releases: no update is ever reported for it.
	ReleaseBuild bool `json:"release_build"`
	// ChecksEnabled is false when updates.check is off: the hub never contacts
	// the release server.
	ChecksEnabled bool    `json:"checks_enabled"`
	Mode          Mode    `json:"mode"`
	Channel       Channel `json:"channel"`
	WindowStart   string  `json:"window_start,omitempty"`
	WindowEnd     string  `json:"window_end,omitempty"`
	// Platform is the build of the release this hub would download.
	Platform string `json:"platform"`

	CheckedAt  *time.Time `json:"checked_at"`
	CheckError string     `json:"check_error,omitempty"`
	Checking   bool       `json:"checking"`
	// Latest is the newest release on the channel at the last check.
	Latest          *Info `json:"latest"`
	UpdateAvailable bool  `json:"update_available"`

	// Staged is the downloaded and checked release waiting in the cache.
	Staged        *Staged `json:"staged"`
	Downloading   bool    `json:"downloading"`
	DownloadError string  `json:"download_error,omitempty"`

	// ApplyEnabled is true when this hub can have an update installed (the
	// helper is set up; see updates.apply). ApplyAvailable adds that a
	// verified release is waiting. Applying is true from the request until the
	// helper has finished, and ApplyStalled when nothing picked the request up.
	ApplyEnabled   bool `json:"apply_enabled"`
	ApplyAvailable bool `json:"apply_available"`
	Applying       bool `json:"applying"`
	ApplyStalled   bool `json:"apply_stalled,omitempty"`
	// LastApply is the outcome of the last installation.
	LastApply *ApplyResult `json:"last_apply"`
}

type TrustSource func(ctx context.Context) (root.TrustedMaterial, error)

type Verifier interface {
	// Verify checks the Sigstore bundle of checksums for the release at tag.
	Verify(ctx context.Context, tag string, checksums, bundleJSON []byte) error
}

type Version struct {
	Major, Minor, Patch uint64
	// Pre holds the dot-separated pre-release identifiers, such as ["beta", "1"].
	Pre []string
}