dashboard

type HubDeliveryMarker struct {
	ID         string    `json:"id,omitempty"`
	Event      string    `json:"event,omitempty"`
	OccurredAt time.Time `json:"occurred_at"`
}

type HubHealth struct {
	Mounted               bool               `json:"mounted"`
	Polling               bool               `json:"polling"`
	PollIntervalSeconds   float64            `json:"poll_interval_seconds,omitempty"`
	RepositoriesPolled    int                `json:"repositories_polled"`
	LastEventReceived     *HubDeliveryMarker `json:"last_event_received,omitempty"`
	LastEventAcknowledged *HubDeliveryMarker `json:"last_event_acknowledged,omitempty"`
	// WebhookRedelivery is the missed-webhook recovery sweep's last completed
	// pass, or nil without a configured GitHub App.
	WebhookRedelivery *HubRedeliverySweep `json:"webhook_redelivery,omitempty"`
}

type HubRedeliverySweep struct {
	LastSweepAt *time.Time `json:"last_sweep_at,omitempty"`
	Redelivered int        `json:"redelivered"`
	Abandoned   int        `json:"abandoned"`
	// Uncounted is how many redeliver calls the last pass made without
	// evidence the operator's endpoint is answering at all, so they were not
	// spent against the 3-attempt limit. A sustained non-zero value is what
	// makes an ongoing outage visible even though nothing is being
	// abandoned for it.
	Uncounted int `json:"uncounted"`
	// LastFailureAt and LastFailureClass are sticky: they report the most
	// recent failure even after a later sweep succeeds, so an operator can
	// tell "this has failed before" from a snapshot taken well afterward.
	LastFailureAt    *time.Time `json:"last_failure_at,omitempty"`
	LastFailureClass string     `json:"last_failure_class,omitempty"`
}

type Inventory struct {
	SourceFingerprint string    `json:"source_fingerprint,omitempty"`
	ObservedAt        time.Time `json:"observed_at,omitempty"`
	CacheHit          bool      `json:"cache_hit"`
}

type Machine struct {
	Name    string `json:"name"`
	Version string `json:"wb_version"`
}

type Options struct {
	ProjectsRoot        string
	Version             string
	DaemonPID           int
	SchedulerGeneration uint64
	Now                 func() time.Time
	CacheTTL            time.Duration
	InventoryIndexPath  string
	InventoryIndexTTL   time.Duration
	// Mounts attaches extra subtrees to the same loopback listener, keyed by
	// the path prefix each one owns (it must start and end with "/"). A
	// self-hosted bench uses it for the hub API under /v0/workbench/ and the
	// embedded dashboard under /workbench/; without a hub section the map is
	// empty and the served routes are exactly what they were.
	Mounts map[string]http.Handler
	// Hub reports the live state of a self-hosted bench hub for
	// /api/v1/health. `wb daemon status` runs in a different process from
	// `wb daemon serve`, so the numbers only this process knows — how many
	// repositories the last poll tick read, and the delivery markers the hub's
	// own StatusService resolves — reach it through the health endpoint rather
	// than by opening the hub's store a second time. Nil when there is no hub.
	Hub func(context.Context) HubHealth
	// LogPath is the daemon's own runtime log file. When set, /api/v1/log
	// serves a tail of it to the owner — the daemon is the log's only
	// authority, so a reverse proxy in front of it never needs disk access of
	// its own. Empty disables the endpoint (503, to the owner only).
	LogPath string
	// Owner reports whether a request acts as the owner principal. It is the
	// seam the daemon fills with Cockpit's own session check
	// (cockpit.Server.IsOwner), so this package neither imports Cockpit nor
	// has a second authentication mechanism. The log is file content, and
	// file content is the owner's alone (cockpit#req:daemon-log-is-owner-only):
	// with no Owner the log route refuses every request.
	Owner func(*http.Request) bool
	// Peers serves /api/v1/peers and /api/v1/peers/{id}
	// (peer-connectivity#req:peers-api's "mounted...on every node"). The
	// caller always supplies one, backed by an empty-list source when this
	// daemon has no hub mounted, so a laptop-only install answers "no
	// downstream peers" instead of falling through to the index page below.
	// A nil value keeps the previous behaviour (unmounted, 404s into the
	// index) purely as a defensive default; every real caller sets it.
	Peers http.Handler
	// Logf is where a failed overview says why, in the daemon's own log, which is
	// the owner's alone; the route itself answers a fixed message. Nil discards.
	Logf func(format string, args ...any)
}

type Overview struct {
	SchemaVersion int            `json:"schema_version"`
	GeneratedAt   time.Time      `json:"generated_at"`
	Machine       Machine        `json:"machine"`
	Operations    runlog.Summary `json:"operations"`
	Worktrees     []Worktree     `json:"worktrees"`
	Diagnostics   int            `json:"diagnostics"`
	Inventory     Inventory      `json:"inventory"`
}

type Worktree struct {
	Task           string    `json:"task"`
	Repository     string    `json:"repository"`
	Branch         string    `json:"branch"`
	Owner          string    `json:"owner,omitempty"`
	OwnerState     string    `json:"owner_state"`
	AgeSeconds     int64     `json:"age_seconds,omitempty"`
	LastActivityAt time.Time `json:"last_activity_at,omitempty"`
}