dogeboxd

type Action interface {
	ActionName() string
}

type ActionLogger interface {
	Progress(p int)
	Step(step string) SubLogger
}

type ActionProgress struct {
	ActionID  string        `json:"actionID"`
	PupID     string        `json:"pupID"`      // optional, only if a pup action
	Progress  int           `json:"progress"`   // 0-100
	Step      string        `json:"step"`       // a unique name for the step we're up to, ie: installing
	Msg       string        `json:"msg"`        // the message line
	Error     bool          `json:"error"`      // if this represents an error or not
	StepTaken time.Duration `json:"step_taken"` // time taken from previous step
}

type AddBinaryCache struct {
	Host string
	Key  string
}

type AddSSHKey struct {
	Key string
}

type AdoptPupOptions struct {
	/// Install pup with development features enabled
	DevMode bool
}

type BootstrapInstallationBootMedia string

type BootstrapInstallationState string

type Buffer[T any] struct {
	Values []T
	Tail   int
}

type Change struct {
	ID string `json:"id"`
	// Seq is a monotonically increasing sequence number for ordering changes on the client.
	// It is assigned server-side when the Change is emitted.
	Seq uint64 `json:"seq"`
	// TS is the server timestamp in milliseconds since epoch, assigned when emitted.
	TS     int64  `json:"ts"`
	Error  string `json:"error"`
	Type   string `json:"type"`
	Update Update `json:"update"`
}

type CheckPupUpdates struct {
	PupID string // Empty string = check all pups
}

type ConsoleSubLogger struct {
	PupID string
	// contains filtered or unexported fields
}

type DKMErrorResponse struct {
	Error  string `json:"error"`
	Reason string `json:"reason"`
}

type DKMErrorResponseMakeDelegate struct {
	Error  string `json:"error"`
	Reason string `json:"reason"`
}

type DKMManager interface {
	CreateKey(password string) ([]string, error)
	// Returns "" as a token if the password supplied is invalid.
	Authenticate(password string) (string, error, error)
	RefreshToken(old string) (string, bool, error)
	InvalidateToken(token string) (bool, error)
	MakeDelegate(id string, token string) (DKMResponseMakeDelegate, error)
	// ChangePassword changes the master key password. Requires either current_password or seedphrase, and new_password.
	ChangePassword(currentPassword string, seedphrase string, newPassword string) error
}

type DKMRequestMakeDelegate struct {
	ID    string `json:"id"`
	Token string `json:"token"`
}

type DKMResponseAuthenticate struct {
	AuthenticationToken string `json:"token"`
	ValidFor            int    `json:"valid_for"`
}

type DKMResponseChangePassword struct {
	Changed bool `json:"changed"`
}

type DKMResponseCreateKey struct {
	SeedPhrase []string `json:"seedphrase"`
}

type DKMResponseInvalidateToken struct{}

type DKMResponseMakeDelegate struct {
	Pub  string `json:"pub"`
	Priv string `json:"priv"`
	Wif  string `json:"wif"`
}

type DisablePup struct {
	PupID string
}

type DisableSSH struct{}

type DogeboxFlags struct {
	IsFirstTimeWelcomeComplete bool `json:"isFirstTimeWelcomeComplete"`
	IsDeveloperMode            bool `json:"isDeveloperMode"`
}

type DogeboxState struct {
	InitialState  DogeboxStateInitialSetup
	Hostname      string
	KeyMap        string
	Timezone      string
	SSH           DogeboxStateSSHConfig
	StorageDevice string
	Flags         DogeboxFlags
	BinaryCaches  []DogeboxStateBinaryCache
	SidebarPups   []string `json:"sidebarPups"` // Pup IDs pinned to dpanel sidebar
}

type DogeboxStateBinaryCache struct {
	ID   string `json:"id"`
	Host string `json:"host"`
	Key  string `json:"key"`
}

type DogeboxStateInitialSetup struct {
	HasGeneratedKey    bool `json:"hasGeneratedKey"`
	HasSetNetwork      bool `json:"hasSetNetwork"`
	HasFullyConfigured bool `json:"hasFullyConfigured"`
}

type DogeboxStateSSHConfig struct {
	Enabled bool                 `json:"enabled"`
	Keys    []DogeboxStateSSHKey `json:"keys"`
}

type DogeboxStateSSHKey struct {
	ID        string    `json:"id"`
	DateAdded time.Time `json:"dateAdded"`
	Key       string    `json:"key"`
}

type Dogeboxd struct {
	Pups             PupManager
	SystemUpdater    SystemUpdater
	SystemMonitor    SystemMonitor
	JournalReader    JournalReader
	NetworkManager   NetworkManager
	PupUpdateChecker PupUpdateChecker

	Changes    chan Change
	JobManager *JobManager
	// contains filtered or unexported fields
}

type EnablePup struct {
	PupID string
}

type EnableSSH struct{}

type EnvEntry struct {
	KEY string
	VAL string
}

type ImportBlockchainData struct{}

type InstallPup struct {
	PupName    string
	PupVersion string
	SourceId   string
	Options    AdoptPupOptions

	SessionToken string
}

type InstallPups []InstallPup

type Job struct {
	A       Action
	ID      string
	Err     string
	Success any
	Start   time.Time // set when the job is first created, for calculating duration
	Logger  *actionLogger
	State   *PupState // nilable, check before use!
}

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

type JobRecord struct {
	ID             string     `json:"id"`
	Started        time.Time  `json:"started"`
	Finished       *time.Time `json:"finished"` // nil if not finished
	DisplayName    string     `json:"displayName"`
	Action         string     `json:"action"`   // Action type: install, upgrade, uninstall, etc.
	Progress       int        `json:"progress"` // 0-100
	Status         JobStatus  `json:"status"`
	SummaryMessage string     `json:"summaryMessage"`
	ErrorMessage   string     `json:"errorMessage"`
	PupID          string     `json:"pupID"` // Associated pup if applicable
}

type JobStatus string

type JobsUpdate struct {
	Jobs []JobRecord `json:"jobs"`
}

type JournalReader interface {
	GetJournalChannel(string) (context.CancelFunc, chan string, error)
}

type LifecycleManager interface {
	Shutdown()
	Reboot()
}

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

type LogTailer interface {
	GetChannel(string) (context.CancelFunc, chan string, error)
}

type ManifestSource interface {
	ValidateFromLocation(location string) (ManifestSourceConfiguration, error)
	Config() ManifestSourceConfiguration
	List(ignoreCache bool) (ManifestSourceList, error)
	Download(diskPath string, remoteLocation map[string]string) error
}

type ManifestSourceConfiguration struct {
	ID          string `json:"id"`
	Name        string `json:"name"`
	Description string `json:"description"`
	Location    string `json:"location"`
	Type        string `json:"type"`
}

type ManifestSourceList struct {
	Config      ManifestSourceConfiguration
	LastChecked time.Time
	Pups        []ManifestSourcePup
	Error       string `json:"error,omitempty"`
}

type ManifestSourcePup struct {
	Name         string
	Location     map[string]string
	Version      string
	Manifest     PupManifest
	LogoBase64   string
	ReleaseNotes string
	ReleaseDate  *time.Time
	ReleaseURL   string
}

type NetworkConnection interface {
	// contains filtered or unexported methods
}

type NetworkConnector interface {
	Connect(network SelectedNetwork) error
}

type NetworkEthernet struct {
	Type      string `json:"type"`
	Interface string `json:"interface"`
}

type NetworkManager interface {
	GetAvailableNetworks() []NetworkConnection
	SetPendingNetwork(selectedNetwork SelectedNetwork, j Job) error
	TryConnect(nixPatch NixPatch) error
	TestConnect() error
	GetLocalIP() (net.IP, error)
}

type NetworkPersistor interface {
	Persist(nixPatch NixPatch, network SelectedNetwork)
}

type NetworkState struct {
	CurrentNetwork SelectedNetwork
	PendingNetwork SelectedNetwork
}

type NetworkWifi struct {
	Type      string            `json:"type"`
	Interface string            `json:"interface"`
	Ssids     []NetworkWifiSSID `json:"ssids"`
}

type NetworkWifiSSID struct {
	Ssid       string  `json:"ssid"`
	Bssid      string  `json:"bssid"` // TODO: this should probably not be a string?
	Encryption string  `json:"encryption,omitempty"`
	Quality    float32 `json:"quality"`
	Signal     string  `json:"signal"`
}

type NixFirewallTemplateValues struct {
	SSH_ENABLED bool
	PUP_PORTS   []struct {
		PORT   int
		PUBLIC bool
		PUP_ID string
	}
}

type NixIncludesFileTemplateValues struct {
	NIX_DIR string
	PUP_IDS []string
}

type NixManager interface {
	// NixPatch passthrough helpers.
	InitSystem(patch NixPatch, dbxState DogeboxState)
	UpdateIncludesFile(patch NixPatch, pups PupManager)
	WritePupFile(patch NixPatch, state PupState, dbxState DogeboxState)
	RemovePupFile(patch NixPatch, pupId string)
	UpdateSystemContainerConfiguration(patch NixPatch)
	UpdateFirewallRules(patch NixPatch, dbxState DogeboxState)
	UpdateNetwork(patch NixPatch, values NixNetworkTemplateValues)
	UpdateSystem(patch NixPatch, values NixSystemTemplateValues)
	UpdateStorageOverlay(patch NixPatch, partitionName string)

	RebuildBoot(log SubLogger) error
	Rebuild(log SubLogger) error

	NewPatch(log SubLogger) NixPatch
}

type NixNetworkTemplateValues struct {
	USE_ETHERNET  bool
	USE_WIRELESS  bool
	INTERFACE     string
	WIFI_SSID     string
	WIFI_PASSWORD string
}

type NixPatch interface {
	State() string
	Apply() error
	ApplyCustom(options NixPatchApplyOptions) error

	Cancel() error

	UpdateSystemContainerConfiguration(values NixSystemContainerConfigTemplateValues)
	UpdateFirewall(values NixFirewallTemplateValues)
	UpdateSystem(values NixSystemTemplateValues)
	UpdateNetwork(values NixNetworkTemplateValues)
	UpdateIncludesFile(values NixIncludesFileTemplateValues)
	WritePupFile(pupId string, values NixPupContainerTemplateValues)
	RemovePupFile(pupId string)
	UpdateStorageOverlay(values NixStorageOverlayTemplateValues)
}

type NixPatchApplyOptions struct {
	RebuildBoot        bool
	DangerousNoRebuild bool
}

type NixPupContainerServiceValues struct {
	NAME string
	EXEC string
	CWD  string
	ENV  []EnvEntry
}

type NixPupContainerTemplateValues struct {
	DATA_DIR          string
	CONTAINER_LOG_DIR string
	PUP_ID            string
	PUP_ENABLED       bool
	INTERNAL_IP       string
	PUP_PORTS         []struct {
		PORT   int
		PUBLIC bool
	}
	STORAGE_PATH string
	PUP_PATH     string
	NIX_FILE     string
	SERVICES     []NixPupContainerServiceValues
	PUP_ENV      []EnvEntry
	GLOBAL_ENV   []EnvEntry

	IS_DEV_MODE       bool
	DEV_MODE_SERVICES []string
}

type NixStorageOverlayTemplateValues struct {
	STORAGE_DEVICE string
	DATA_DIR       string
	DBX_UID        string
}

type NixSystemContainerConfigTemplatePupRequiresInternet struct {
	PUP_ID string
	PUP_IP string
}

type NixSystemContainerConfigTemplatePupTcpConnection struct {
	NAME       string
	ID         string
	IP         string
	OTHER_PUPS []NixSystemContainerConfigTemplatePupTcpConnectionOtherPup
}

type NixSystemContainerConfigTemplatePupTcpConnectionOtherPup struct {
	NAME  string
	ID    string
	IP    string
	PORTS []struct {
		PORT int
	}
}

type NixSystemContainerConfigTemplateValues struct {
	DOGEBOX_HOST_IP         string
	DOGEBOX_CONTAINER_CIDR  string
	PUPS_REQUIRING_INTERNET []NixSystemContainerConfigTemplatePupRequiresInternet
	PUPS_TCP_CONNECTIONS    []NixSystemContainerConfigTemplatePupTcpConnection
}

type NixSystemTemplateValues struct {
	SYSTEM_HOSTNAME   string
	KEYMAP            string
	TIMEZONE          string
	SSH_ENABLED       bool
	SSH_KEYS          []DogeboxStateSSHKey
	BINARY_CACHE_SUBS []string
	BINARY_CACHE_KEYS []string
}

type ProcStatus struct {
	CPUPercent float64 `json:"cpuPercent"`
	MEMPercent float64 `json:"memPercent"`
	MEMMb      float64 `json:"memMb"`
	Running    bool    `json:"running"`

	// ActiveState/SubState come from systemd and help disambiguate transient states
	// like activating/deactivating even when MainPID is not yet (or no longer) present.
	ActiveState string `json:"activeState,omitempty"`
	SubState    string `json:"subState,omitempty"`
}

type PupAsset struct {
	Logos PupLogos `json:"logos"`
}

type PupDependencyReport struct {
	Interface             string                        `json:"interface"`
	Version               string                        `json:"version"`
	Optional              bool                          `json:"optional"`
	CurrentProvider       string                        `json:"currentProvider"`
	InstalledProviders    []string                      `json:"installedProviders"`
	InstallableProviders  []PupManifestDependencySource `json:"InstallableProviders"`
	DefaultSourceProvider PupManifestDependencySource   `json:"DefaultProvider"`
}

type PupHealthStateReport struct {
	Issues    PupIssues
	NeedsConf bool
	NeedsDeps bool
}

type PupHook struct {
	Port int    `json:"port"`
	Path string `json:"path"`
	ID   string `json:"id"`
}

type PupInterfaceVersion struct {
	InterfaceName string   `json:"interfaceName"`
	OldVersion    string   `json:"oldVersion"`
	NewVersion    string   `json:"newVersion"`
	ChangeType    string   `json:"changeType"`   // "major", "minor", "patch"
	AffectedPups  []string `json:"affectedPups"` // PupIDs that depend on this interface
}

type PupIssues struct {
	DepsNotRunning   []string `json:"depsNotRunning"`
	HealthWarnings   []string `json:"healthWarnings"`
	UpgradeAvaialble bool     `json:"upgradeAvailable"`
}

type PupLogos struct {
	MainLogoBase64 string `json:"mainLogoBase64"`
}

type PupManager interface {
	// Run starts the PupManager as a service.
	Run(started, stopped chan bool, stop chan context.Context) error

	// GetUpdateChannel returns a channel for receiving pup updates.
	GetUpdateChannel() chan Pupdate

	// GetStatsChannel returns a channel for receiving pup stats.
	GetStatsChannel() chan []PupStats

	// GetStateMap returns a map of all pup states.
	GetStateMap() map[string]PupState

	// GetStatsMap returns a map of all pup stats.
	GetStatsMap() map[string]PupStats

	// GetAssetsMap returns a map of pup assets like logos.
	GetAssetsMap() map[string]PupAsset

	// AdoptPup adds a new pup from a manifest. It returns the PupID and an error if any.
	AdoptPup(m PupManifest, source ManifestSource, options AdoptPupOptions) (string, error)

	// UpdatePup updates the state of a pup with provided update functions.
	UpdatePup(id string, updates ...func(*PupState, *[]Pupdate)) (PupState, error)

	// PurgePup removes a pup and its state from the manager.
	PurgePup(pupId string) error

	// GetPup retrieves the state and stats for a specific pup by ID.
	GetPup(id string) (PupState, PupStats, error)

	// FindPupByIP retrieves a pup by its assigned IP address.
	FindPupByIP(ip string) (PupState, PupStats, error)

	// GetAllFromSource retrieves all pups from a specific source.
	GetAllFromSource(source ManifestSourceConfiguration) []*PupState

	// GetPupFromSource retrieves a specific pup by name from a source.
	GetPupFromSource(name string, source ManifestSourceConfiguration) *PupState

	// GetMetrics retrieves the metrics for a specific pup.
	GetMetrics(pupId string) map[string]interface{}

	// UpdateMetrics updates the metrics for a pup based on provided data.
	UpdateMetrics(u UpdateMetrics)

	// CanPupStart checks if a pup can start based on its current state and dependencies.
	CanPupStart(pupId string) (bool, error)

	// GetPupHealthState returns the health state report for a pup.
	GetPupHealthState(pup *PupState) PupHealthStateReport

	// CalculateDeps calculates the dependencies for a pup.
	CalculateDeps(pupID string) ([]PupDependencyReport, error)

	// SetSourceManager sets the SourceManager for the PupManager.
	SetSourceManager(sourceManager SourceManager)

	// FastPollPup initiates a rapid polling of a specific pup for debugging or immediate updates.
	FastPollPup(pupId string)

	GetPupSpecificEnvironmentVariablesForContainer(pupID string) map[string]string

	// StopPup stops a running pup by disabling it and triggering a rebuild
	StopPup(pupID string, nixManager NixManager, logger SubLogger) error

	// StartPup starts a stopped pup by enabling it and triggering a rebuild
	StartPup(pupID string, nixManager NixManager, logger SubLogger) error

	// Snapshot management
	CreateSnapshot(pupState PupState) error
	GetSnapshot(pupID string) (*PupVersionSnapshot, error)
	HasSnapshot(pupID string) bool
	DeleteSnapshot(pupID string) error
	ListSnapshots() ([]string, error)
	CleanOldSnapshots(maxAge time.Duration) (int, error)

	// ClearCacheEntry removes a specific pup from the update cache
	ClearCacheEntry(pupID string)
}

type PupManifest struct {
	// The version of the actual manifest. This differs from the "version"
	// of the pup, and the version of the deployed software for this pup.
	// Valid values: 1
	ManifestVersion int                     `json:"manifestVersion"`
	Meta            PupManifestMeta         `json:"meta"`
	Config          PupManifestConfigFields `json:"config"`
	Container       PupManifestContainer    `json:"container"`
	Interfaces      []PupManifestInterface  `json:"interfaces"`
	Dependencies    []PupManifestDependency `json:"dependencies"`
	Metrics         []PupManifestMetric     `json:"metrics"`
}

type PupManifestBuild struct {
	// The location of the nix file used for building this pups environment.
	NixFile string `json:"nixFile"`
	// The SHA256 hash of the nix file.
	NixFileSha256 string `json:"nixFileSha256"`
}

type PupManifestCommand struct {
	// Required. The whole executable string, including any arguments that need to be passed.
	Exec string `json:"exec"`
	// Optional. The working directory specified for a systemd service.
	CWD string `json:"cwd"`
	// Optional. Any environment variables that need to be set.
	ENV map[string]string `json:"env"`
}

type PupManifestConfigField struct {
	Label       string   `json:"label"`
	Name        string   `json:"name"`
	Type        string   `json:"type"`
	Required    bool     `json:"required"`
	Placeholder string   `json:"placeholder,omitempty"`
	Help        string   `json:"help,omitempty"`
	Default     any      `json:"default,omitempty"`
	Min         *float64 `json:"min,omitempty"`
	Max         *float64 `json:"max,omitempty"`
	Step        *float64 `json:"step,omitempty"`
}

type PupManifestConfigFields struct {
	ShowOnInstall bool                       `json:"showOnInstall"`
	Sections      []PupManifestConfigSection `json:"sections"`
}

type PupManifestConfigSection struct {
	Name   string                   `json:"name"`
	Label  string                   `json:"label"`
	Fields []PupManifestConfigField `json:"fields"`
}

type PupManifestContainer struct {
	Build PupManifestBuild `json:"build"`
	// A single nix build file can provide multiple services, which all
	// may need to be started separately. Each "service" should be provided
	// as an artifact here with the correct execution configuration.
	Services []PupManifestService      `json:"services"`
	Exposes  []PupManifestExposeConfig `json:"exposes"`
	// This pup requires internet access to function.
	RequiresInternet bool `json:"requiresInternet"`
}

type PupManifestDependency struct {
	InterfaceName    string                      `json:"interfaceName"`    // interface that we depend on
	InterfaceVersion string                      `json:"interfaceVersion"` // semver expression
	PermissionGroups []string                    `json:"permissionGroups"` // list of permission groups from that interface we want
	DefaultSource    PupManifestDependencySource `json:"source"`           // optional, default package that provides this interface
	Optional         bool                        `json:"optional"`
}

type PupManifestDependencySource struct {
	SourceLocation string `json:"sourceLocation"`
	PupName        string `json:"pupName"`
	PupVersion     string `json:"pupVersion"`
	PupLogoBase64  string `json:"pupLogoBase64"`
}

type PupManifestExposeConfig struct {
	Name         string   `json:"name"`         // Freeform field used to refer to this port in the frontend.
	Type         string   `json:"type"`         // Must be one of: http, tcp
	Port         int      `json:"port"`         // The port that is being listened on inside the container.
	Interfaces   []string `json:"interfaces"`   // Designates that certain interfaces can be accessed on this port
	ListenOnHost bool     `json:"listenOnHost"` // If true, the port will be accessible on the host network, otherwise it will listen on a private internal network interface.
	WebUI        bool     `json:"webUI"`        // If true, will be proxied from an available port to the dPanel user
}

type PupManifestInterface struct {
	Name             string                       `json:"name"`             // the globally unique name for this interface
	Version          string                       `json:"version"`          // Semver ie: 0.1.1
	PermissionGroups []PupManifestPermissionGroup `json:"permissionGroups"` // The permission groups that make up this interface
}

type PupManifestMeta struct {
	Name string `json:"name"`
	// The version of the pup.
	// nb. This can differ from the version of the software deployed
	//     by this pup, as we may change this pup manifest to expose
	//     additional configuration options for the same software version.
	Version string `json:"version"`
	// Optional. A path to a logo for this pup.
	LogoPath string `json:"logoPath"`
	// A short description, single line.
	ShortDescription string `json:"shortDescription"`
	// Optional, longer description. Used for store listings.
	LongDescription string `json:"longDescription"`
	// A key value pair of upstream versions that this pup ships with.
	UpstreamVersions map[string]string `json:"upstreamVersions"`
}

type PupManifestMetric struct {
	Name        string `json:"name"`
	Label       string `json:"label"`
	Type        string `json:"type"` // string, int, float
	HistorySize int    `json:"history"`
	Description string `json:"description,omitempty"`
}

type PupManifestPermissionGroup struct {
	Name        string   `json:"name"`        // ie:  admin, wallet-read-only, etc.
	Description string   `json:"description"` // What does this permission group do (shown to user)
	Severity    int      `json:"severity"`    // 1-3, 1: critical/danger, 2: makes changes, 3: read only stuff
	Routes      []string `json:"routes"`      // http routes accessible for this group
	Port        int      `json:"port"`        // port accessible for this group
}

type PupManifestService struct {
	Name    string             `json:"name"`
	Command PupManifestCommand `json:"command"`
}

type PupMetric struct {
	Value any `json:"value"`
}

type PupMetrics[T any] struct {
	Name   string     `json:"name"`
	Label  string     `json:"label"`
	Type   string     `json:"type"`
	Values *Buffer[T] `json:"values"`
}

type PupState struct {
	ID           string                      `json:"id"`
	LogoBase64   string                      `json:"logoBase64"`
	Source       ManifestSourceConfiguration `json:"source"`
	Manifest     PupManifest                 `json:"manifest"`
	Config       map[string]string           `json:"config"`
	ConfigSaved  bool                        `json:"configSaved"`  // Has config been saved at least once?
	Providers    map[string]string           `json:"providers"`    // providers of interface dependencies
	Hooks        []PupHook                   `json:"hooks"`        // webhooks
	Installation string                      `json:"installation"` // see table above and constants
	BrokenReason string                      `json:"brokenReason"` // reason for being in a broken state
	Enabled      bool                        `json:"enabled"`      // Is this pup supposed to be running?
	NeedsConf    bool                        `json:"needsConf"`    // Has all required config been provided?
	NeedsDeps    bool                        `json:"needsDeps"`    // Have all dependencies been met?
	IP           string                      `json:"ip"`           // Internal IP for this pup
	Version      string                      `json:"version"`
	WebUIs       []PupWebUI                  `json:"webUIs"`

	IsDevModeEnabled bool     `json:"isDevModeEnabled"`
	DevModeServices  []string `json:"devModeServices"`

	// Update management
	SkippedVersion string `json:"skippedVersion,omitempty"` // Version up to which updates are skipped
}

type PupStats struct {
	ID            string            `json:"id"`
	Status        string            `json:"status"`
	SystemMetrics []PupMetrics[any] `json:"systemMetrics"`
	Metrics       []PupMetrics[any] `json:"metrics"`
	Issues        PupIssues         `json:"issues"`
}

type PupUpdateChecker interface {
	// CheckForUpdates checks for updates for a specific pup
	CheckForUpdates(pupID string) (PupUpdateInfo, error)

	// CheckAllPupUpdates checks for updates for all installed pups
	CheckAllPupUpdates() map[string]PupUpdateInfo

	// GetCachedUpdateInfo retrieves update information from the cache
	GetCachedUpdateInfo(pupID string) (PupUpdateInfo, bool)

	// GetAllCachedUpdates retrieves all update information from the cache
	GetAllCachedUpdates() map[string]PupUpdateInfo

	// ClearCacheEntry removes a specific pup from the update cache
	ClearCacheEntry(pupID string)

	// StartPeriodicCheck starts a background goroutine that checks for updates periodically
	StartPeriodicCheck(stop chan bool)

	// GetEventChannel returns the channel for update check completion events
	GetEventChannel() <-chan PupUpdatesCheckedEvent

	// DetectInterfaceChanges compares interfaces between two manifests and returns changes
	DetectInterfaceChanges(oldManifest, newManifest PupManifest) []PupInterfaceVersion
}

type PupUpdateInfo struct {
	PupID             string       `json:"pupId"`
	CurrentVersion    string       `json:"currentVersion"`
	LatestVersion     string       `json:"latestVersion"`
	AvailableVersions []PupVersion `json:"availableVersions"`
	UpdateAvailable   bool         `json:"updateAvailable"`
	LastChecked       time.Time    `json:"lastChecked"`
}

type PupUpdatePreviousVersion struct {
	PupID           string              `json:"pupId"`
	PreviousVersion *PupVersionSnapshot `json:"previousVersion"` // Only keep last version
}

type PupUpdatesCheckedEvent struct {
	PupsChecked      int  `json:"pupsChecked"`
	UpdatesAvailable int  `json:"updatesAvailable"`
	IsPeriodicCheck  bool `json:"isPeriodicCheck"`
}

type PupVersion struct {
	Version          string                `json:"version"`
	ReleaseNotes     string                `json:"releaseNotes,omitempty"`
	ReleaseDate      *time.Time            `json:"releaseDate,omitempty"`
	ReleaseURL       string                `json:"releaseUrl,omitempty"`
	BreakingChanges  []string              `json:"breakingChanges,omitempty"`
	InterfaceChanges []PupInterfaceVersion `json:"interfaceChanges,omitempty"`
}

type PupVersionSnapshot struct {
	Version        string            `json:"version"`
	Manifest       PupManifest       `json:"manifest"`
	Config         map[string]string `json:"config"`
	Providers      map[string]string `json:"providers"`
	Enabled        bool              `json:"enabled"`
	SnapshotDate   time.Time         `json:"snapshotDate"`
	SourceID       string            `json:"sourceId"`
	SourceLocation string            `json:"sourceLocation"` // For re-downloading
}

type PupWebUI struct {
	Name     string `json:"name"`
	Internal int    `json:"-"`
	Port     int    `json:"port"`
}

type Pupdate struct {
	ID    string
	Event int // see consts above ^
	State PupState
}

type PurgePup struct {
	PupID string
}

type RemoveBinaryCache struct {
	ID string
}

type RemoveSSHKey struct {
	ID string
}

type RollbackPupUpgrade struct {
	PupID string
}

type SaveCustomNix struct {
	Content string `json:"content"`
}

type SelectedNetwork interface {
	// contains filtered or unexported methods
}

type SelectedNetworkEthernet struct {
	SelectedNetwork
	Interface string `json:"interface"`
}

type SelectedNetworkWifi struct {
	SelectedNetwork
	Interface  string `json:"interface"`
	Ssid       string `json:"ssid"`
	Password   string `json:"password"`
	Encryption string `json:"encryption"`
	IsHidden   bool   `json:"isHidden"`
}

type ServerConfig struct {
	DataDir          string
	TmpDir           string
	NixDir           string
	ContainerLogDir  string
	Bind             string
	Port             int
	InternalPort     int
	Verbose          bool
	Recovery         bool
	UiDir            string
	UiPort           int
	DevMode          bool
	DisableReflector bool
	UnixSocketPath   string
}

type SourceDetails struct {
	ID          string             `json:"id"`
	Name        string             `json:"name"`
	Description string             `json:"description"`
	Pups        []SourceDetailsPup `json:"pups"`
}

type SourceDetailsPup struct {
	Location string `json:"location"`
}

type SourceManager interface {
	GetAll(ignoreCache bool) (map[string]ManifestSourceList, error)
	GetSourceManifest(sourceId, pupName, pupVersion string) (PupManifest, ManifestSource, error)
	GetSourcePup(sourceId, pupName, pupVersion string) (ManifestSourcePup, error)
	GetSource(name string) (ManifestSource, error)
	AddSource(location string) (ManifestSource, error)
	RemoveSource(id string) error
	DownloadPup(diskPath, sourceId, pupName, pupVersion string) (PupManifest, error)
	GetAllSourceConfigurations() []ManifestSourceConfiguration
}

type SourceState struct {
	SourceConfigs []ManifestSourceConfiguration
}

type State struct {
	Network NetworkState
	Dogebox DogeboxState
	Sources SourceState
}

type StateManager interface {
	Get() State
	CloseDB() error
	OpenDB() error
	SetNetwork(s NetworkState) error
	SetDogebox(s DogeboxState) error
	SetSources(s SourceState) error
}

type StatsUpdate struct {
	Stats []PupStats `json:"stats"`
}

type StoreManager struct {
	DBPath  string
	DB      *sql.DB
	WriteMu sync.Mutex
}

type SubLogger interface {
	Log(msg string)
	Logf(msg string, a ...any)
	Err(msg string)
	Errf(msg string, a ...any)
	Progress(p int) SubLogger
	LogCmd(cmd *exec.Cmd)
}

type SystemDisk struct {
	Name        string                `json:"name"`
	Size        int64                 `json:"size"`
	SizePretty  string                `json:"sizePretty"`
	Suitability SystemDiskSuitability `json:"suitability"`
	BootMedia   bool                  `json:"bootMedia"`
	Label       string                `json:"label"`
	Path        string                `json:"path"`
	MountPoints []string              `json:"mountPoints,omitempty"`
	Children    []SystemDisk          `json:"children,omitempty"`
}

type SystemDiskSuitability struct {
	Install       SystemDiskSuitabilityEntry `json:"install"`
	Storage       SystemDiskSuitabilityEntry `json:"storage"`
	IsAlreadyUsed bool                       `json:"isAlreadyUsed"`
}

type SystemDiskSuitabilityEntry struct {
	Usable bool `json:"usable"`
	SizeOK bool `json:"sizeOK"`
}

type SystemMonitor interface {
	GetMonChannel() chan []string
	GetStatChannel() chan map[string]ProcStatus
	GetFastMonChannel() chan string
	GetFastStatChannel() chan map[string]ProcStatus
}

type SystemUpdate struct {
	Package string
	Version string
}

type SystemUpdater interface {
	AddJob(Job)
	GetUpdateChannel() chan Job

	// These ideally should not be on here, but we currently don't
	// have a way to wait for a SystemUpdater event to finish.
	AddSSHKey(key string, l SubLogger) error
	EnableSSH(l SubLogger) error
	ListSSHKeys() ([]DogeboxStateSSHKey, error)
	AddBinaryCache(j AddBinaryCache, l SubLogger) error
	UpdateSystemConfig(dbxState DogeboxState, log SubLogger) error
	ValidateNix(content string) error

	// Snapshot management for pup rollbacks
	HasSnapshot(pupID string) bool
	GetSnapshot(pupID string) (*PupVersionSnapshot, error)
}

type TypeStore[T any] struct {
	Table string
	// contains filtered or unexported fields
}

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

type UninstallPup struct {
	PupID string
}

type UnknownAction struct {
	Type string
}

type Update any

type UpdateKeymap struct {
	Keymap string
}

type UpdateMetrics struct {
	PupID   string
	Payload map[string]PupMetric
}

type UpdatePendingSystemNetwork struct {
	Network SelectedNetwork
}

type UpdatePupConfig struct {
	PupID   string
	Payload map[string]string
}

type UpdatePupHooks struct {
	PupID   string
	Payload []PupHook
}

type UpdatePupProviders struct {
	PupID   string
	Payload map[string]string
}

type UpdateTimezone struct {
	Timezone string
}

type UpgradePup struct {
	PupID         string
	TargetVersion string
	SourceId      string // Source to download new version from
}