cerberus

type AIModelMetadata struct {
	// ModelName is the human-readable model identifier
	ModelName string `json:"model_name"`

	// ModelVersion is the semantic version of the model
	ModelVersion string `json:"model_version,omitempty"`

	// Checksum is the cryptographic hash of model weights
	// Format: "algorithm:hexdigest" (e.g., "sha256:abc123...")
	Checksum string `json:"checksum"`

	// ChecksumAlgo is the algorithm used (sha256, blake3, etc.)
	ChecksumAlgo string `json:"checksum_algo"`

	// ParameterCount is the number of parameters (for quick identification)
	ParameterCount int64 `json:"parameter_count,omitempty"`

	// QuantizationType describes quantization (Q4_K_M, FP16, etc.)
	QuantizationType string `json:"quantization_type,omitempty"`

	// Framework is the inference framework (llama.cpp, ONNX, etc.)
	Framework string `json:"framework,omitempty"`

	// Source is where the model was obtained (HuggingFace, internal, etc.)
	Source string `json:"source,omitempty"`

	// ApprovedBy is who approved this model version for use
	ApprovedBy string `json:"approved_by,omitempty"`
}

type AgentConfigMetadata struct {
	// AgentID is the unique agent identifier
	AgentID string `json:"agent_id"`

	// ConfigVersion is the semantic version of the config
	ConfigVersion string `json:"config_version,omitempty"`

	// Checksum is the hash of config content
	Checksum string `json:"checksum"`

	// AllowedPlugins lists plugins this agent can use
	AllowedPlugins []string `json:"allowed_plugins,omitempty"`

	// MaxTokenBudget is the maximum tokens per request
	MaxTokenBudget int `json:"max_token_budget,omitempty"`

	// TrustLevel indicates agent privilege level
	TrustLevel string `json:"trust_level,omitempty"`

	// Owner is the team/user responsible for this agent
	Owner string `json:"owner,omitempty"`

	// LastModifiedBy tracks who last changed the config
	LastModifiedBy string `json:"last_modified_by,omitempty"`
}

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

type ChangeType uint8

type Config struct {
	// Deprecated: PollInterval is accepted for backward compatibility but has no
	// effect. Use SensitivityProfile to control polling frequency.
	PollInterval time.Duration

	// BufferSize is the drift event channel buffer size
	// Default: 64
	BufferSize int

	// ProbeTimeout is the maximum time a probe can take before being cancelled
	// Default: 1s
	// SAFETY: Prevents slow/hung probes from blocking the poll loop
	ProbeTimeout time.Duration

	// SensitivityProfile configures per-resource polling intervals
	// If nil, uses DefaultSensitivityForResource() for each probe
	// SOVEREIGNTY: Policy controls sensitivity, not code
	SensitivityProfile *SensitivityProfile

	// OnStateChange is called when any probe's state changes
	// Enables external persistence for baseline recovery after restart
	// SOVEREIGNTY: Cerberus is stateless, persistence is external
	OnStateChange StateChangeHandler

	// CongestionThreshold is the number of dropped events before alerting
	// Default: 10
	CongestionThreshold int64

	// OnCongestion is called when dropped events exceed threshold
	// Critical for GRC compliance - monitoring failures must be visible
	OnCongestion CongestionHandler

	// EmitCongestionEvent sends a DriftEvent when congestion occurs
	// Default: false (opt-in to avoid event flood)
	EmitCongestionEvent bool
}

type CongestionHandler func(droppedCount int64)

type DriftEvent struct {
	ProbeID      string       // Which probe detected this
	ResourceID   string       // What resource drifted
	ResourceType ResourceType // Type of resource
	ChangeType   ChangeType   // What kind of change
	PrevHash     uint64       // Previous state hash
	CurrHash     uint64       // Current state hash
	Timestamp    time.Time    // When detected
	Error        error        // If ChangeType == ChangeError
}

type EnvVarMetadata struct {
	// VarName is the environment variable name
	VarName string `json:"var_name"`

	// Checksum is the hash of the value (never store actual secrets)
	Checksum string `json:"checksum"`

	// Category classifies the variable (api_key, config, path, etc.)
	Category string `json:"category,omitempty"`

	// Sensitive indicates if this is a secret value
	Sensitive bool `json:"sensitive,omitempty"`

	// Source tracks where this var comes from (file, vault, k8s, etc.)
	Source string `json:"source,omitempty"`
}

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

type HealthStatus struct {
	IsHealthy        bool          // True if watchdog is operating normally
	IsRunning        bool          // Whether watchdog is running
	ProbeCount       int           // Number of registered probes
	DroppedEvents    int64         // Number of dropped events
	BufferCapacity   int           // Size of drift event buffer
	BufferUsed       int           // Current buffer usage (approximate)
	LastPollAt       time.Time     // When last poll cycle completed (zero if never polled)
	LastPollDuration time.Duration // Duration of the last poll cycle
	PollOverrun      bool          // True if the last poll cycle exceeded MinPollInterval (sequential bottleneck)
}

type Probe interface {
	// ID returns unique identifier for this probe
	ID() string

	// ResourceType returns what kind of resource this probe monitors
	ResourceType() ResourceType

	// Probe fetches current state and returns it
	// Must be thread-safe, idempotent, and respect context cancellation
	// Context will have a deadline set by Cerberus (ProbeTimeout config)
	Probe(ctx context.Context) (State, error)
}

type ProbeDefinition struct {
	// ID is the unique identifier for the probe
	ID string `json:"id"`

	// ResourceType determines which generator to use
	ResourceType ResourceType `json:"resource_type"`

	// Target is the resource-specific target (path, port, etc.)
	Target string `json:"target"`

	// Sensitivity overrides default sensitivity for this probe
	Sensitivity *Sensitivity `json:"sensitivity,omitempty"`

	// Metadata contains resource-specific configuration
	Metadata map[string]string `json:"metadata,omitempty"`
}

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

type ProbeGenerator func(ctx context.Context, def ProbeDefinition) (Probe, error)

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

type PromptTemplateMetadata struct {
	// TemplateName is the unique template identifier
	TemplateName string `json:"template_name"`

	// Version is the semantic version of the template
	Version string `json:"version,omitempty"`

	// Checksum is the hash of template content
	Checksum string `json:"checksum"`

	// TokenCount is the approximate token count (for budget planning)
	TokenCount int `json:"token_count,omitempty"`

	// Author is who created/last modified the template
	Author string `json:"author,omitempty"`

	// ApprovedAt is when the template was approved for production
	ApprovedAt string `json:"approved_at,omitempty"`

	// Category classifies the template (system, user, tool, etc.)
	Category string `json:"category,omitempty"`

	// SecurityLevel indicates sensitivity (public, internal, confidential)
	SecurityLevel string `json:"security_level,omitempty"`
}

type ResourceType uint8

type Sensitivity uint8

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

type SignedBaseline struct {
	// States is the probe state map being protected
	States map[string]State `json:"states"`

	// Signature is the HMAC-SHA256 signature of canonical state JSON
	Signature string `json:"signature"`

	// Version allows future format changes
	Version int `json:"version"`
}

type State struct {
	ResourceID string    // Unique identifier for the resource
	Hash       uint64    // Hash of current state for fast comparison
	Timestamp  time.Time // When this state was captured
	Metadata   any       // Optional: additional state info for detailed diff
}

type StateChangeHandler func(probeID string, prevState, newState *State)

type Stats struct {
	PollCount        int64         // Total polls executed
	DriftCount       int64         // Total drifts detected
	DroppedCount     int64         // Events dropped due to full buffer
	OverrunCount     int64         // Poll cycles that exceeded MinPollInterval (sequential bottleneck signal)
	ProbeCount       int           // Number of registered probes
	LastPollAt       time.Time     // Wall-clock time when the last poll cycle completed
	LastPollDuration time.Duration // Duration of the last poll cycle
	IsRunning        bool          // Whether watchdog is running
	BaselineCount    int           // Number of baseline entries loaded
}

type ValidationLimits struct {
	// MaxIDLength is the maximum byte length of a ProbeDefinition.ID.
	MaxIDLength int
	// MaxTargetLength is the maximum byte length of ProbeDefinition.Target.
	MaxTargetLength int
	// MaxMetadataKeys is the maximum number of keys in ProbeDefinition.Metadata.
	MaxMetadataKeys int
	// MaxMetadataValueLen is the maximum byte length of any single metadata value.
	MaxMetadataValueLen int
}