clientbuild

type Artifact struct {
	// Reference identifies this build. It is the file's name on disk and the
	// last part of its download address.
	Reference string
	// Name is what the file is called when a driver downloads it.
	Name string
	// Path is where it is on this server.
	Path string
	// Size is the built file's size. Stamping does not change it; signing
	// does, by the length of the signature put on the end.
	Size int64
	// SHA256 is the hex digest of the built file, which is what an operator
	// tells their drivers to check.
	SHA256 string
	// Address is read back out of the file after it was written, so the page
	// shows what the client will actually do rather than what was asked for.
	Address string
	// Signing is the route it was built down.
	Signing Signing
	// SignedBy is the certificate that signed it, for the page to show and the
	// history to record. Empty for an unsigned build.
	SignedBy string
	// Client is the prebuilt client it was stamped from.
	Client Client
	// At is when it was built.
	At time.Time
}

type Builder struct {
	// Source is the prebuilt client.
	Source Source
	// Dir is where built clients are written. Empty means this server cannot
	// keep one, which [Builder.Build] refuses rather than building into
	// nowhere.
	Dir string
	// Now is the clock, injectable for tests.
	Now func() time.Time
	// Certificate is the operator's own code-signing certificate, or nil when
	// they have not given this server one.
	//
	// It is asked for at the moment a client is built rather than held, for
	// two reasons. An operator uploads and removes a certificate while the
	// server runs, so a captured value would go stale; and the private key is
	// sealed in the database, so holding it would mean holding an opened
	// private key in memory for the life of the process to serve a button
	// somebody presses once a month.
	Certificate func(context.Context) (*Certificate, error)
}

type Certificate struct {
	// Leaf is the certificate that signs.
	Leaf *x509.Certificate
	// Chain is everything between the leaf and a root, which travels with the
	// signature so that a machine trusting the root can build the path.
	Chain []*x509.Certificate
	// Key signs.
	Key crypto.Signer
}

type CertificateInfo struct {
	// Subject and Issuer are who the certificate says signed and who vouched
	// for them, as a person reads them.
	Subject, Issuer string
	// NotBefore and NotAfter are the window the signature is made inside.
	NotBefore, NotAfter time.Time
	// Thumbprint is the SHA-256 of the certificate, which is what an operator
	// compares against what their authority issued them.
	Thumbprint string
	// Algorithm is the key, in words: "RSA 3072" or "ECDSA P-256".
	Algorithm string
	// SelfSigned is whether the operator issued it to themselves, which is the
	// normal case here and changes what their drivers will see.
	SelfSigned bool
	// CodeSigning is whether the certificate is marked for signing software.
	// A certificate without it can still make a signature and Windows will not
	// accept it, so the page says so rather than letting an operator find out
	// from a driver.
	CodeSigning bool
}

type Client struct {
	// Path is where this server looked.
	Path string
	// Present is whether there was a file there.
	Present bool
	// Size and ModifiedAt are the file's own facts.
	Size       int64
	ModifiedAt time.Time
	// SHA256 is the hex digest of the prebuilt file, so an operator can check
	// that what they copied onto the server is what they downloaded.
	SHA256 string
	// Module, Version, Revision and BuiltAt come from the build information
	// the Go toolchain records inside every binary it links. They are how the
	// page answers "which version is this" without anybody maintaining a
	// version file beside the executable.
	Module   string
	Version  string
	Revision string
	BuiltAt  time.Time
	// GOOS and GOARCH are what the client was built for, read from the same
	// place. A macOS build sitting in the Windows client's path is a mistake
	// worth naming before an operator hands it to a driver.
	GOOS, GOARCH string
	// Machine is the processor the PE header names, in words.
	Machine string
	// Stampable is whether this server can build clients from this file.
	Stampable bool
	// StampedWith is the address the file already carries, which a prebuilt
	// client normally does not. It is shown rather than hidden: a generic
	// client that already points somewhere is worth knowing about.
	StampedWith string
	// Problem is why it cannot be used, in the words the operator needs.
	// Empty when there is nothing wrong.
	Problem string
}

type Opus struct {
	// Program is the program's name.
	Program string
	// URL is where a driver can read about it.
	URL string
}

type Request struct {
	// Address is the server the built client will talk to.
	Address string
	// Signing is the route the operator chose.
	Signing Signing
	// Program is what Windows calls this client in the dialog it shows a
	// driver who runs it. It is the operator's own organisation, so that a
	// driver in two teams can tell whose client they are about to install.
	// Empty leaves the field out, which Windows renders as "unknown".
	Program string
}

type Signing string

type Source struct {
	// Path is the file. Empty means this server has not been told where the
	// client is, which the page says rather than guessing.
	Path string
}

type Stamp struct {
	// Address is the server the built client talks to: a scheme and a host,
	// with no trailing slash.
	Address string
	// Build identifies the build this copy came from, or is empty.
	Build string
}