Real-time monitoring dashboard for Proxmox VE, PBS, Docker, Kubernetes, TrueNAS and vSphere. Self-hosted, with alerts for failed backups, full disks, unhealthy containers and offline nodes.
Go aialertsdashboarddockerdocker-monitoringgohomelabinfrastructure-monitoringkubernetesmonitoringmspproxmoxproxmox-backup-serverproxmox-mail-gatewayproxmox-veself-hostedtruenastypescriptvspherewebhooks
package tools
import (
"context"
"encoding/json"
"fmt"
"strconv"
"strings"
"time"
"github.com/rcourtman/pulse-go-rewrite/internal/agentcapabilities"
"github.com/rcourtman/pulse-go-rewrite/internal/recovery"
proxmoxrecoverymapper "github.com/rcourtman/pulse-go-rewrite/internal/recovery/mapper/proxmox"
"github.com/rcourtman/pulse-go-rewrite/internal/unifiedresources"
)
// registerStorageTools registers the pulse_storage tool
func (e *PulseToolExecutor) registerStorageTools() {
e.registry.registerBuiltin(RegisteredTool{
Definition: Tool{
Name: agentcapabilities.PulseStorageToolName,
Description: `Query storage pools, backups, snapshots, Ceph, replication, RAID, and disk health. Use the "type" parameter to select what to query. backups returns collected backup artifact records from the canonical recovery inventory, including repository references and verification evidence when collected. backup_tasks returns collected backup attempt status, timestamps and failure error text without requiring host command access. Neither an artifact record nor task success alone proves a restorable backup exists.`,
InputSchema: InputSchema{
Type: "object",
Properties: map[string]PropertySchema{
"type": {
Type: "string",
Description: "Storage type to query",
Enum: []string{"pools", "backups", "backup_tasks", "snapshots", "ceph", "ceph_details", "replication", "pbs_jobs", "raid", "disk_health", "resource_disks"},
},
"storage_id": {
Type: "string",
Description: "Filter by storage ID (for pools)",
},
"resource_id": {
Type: "string",
Description: "Filter by resource ID (canonical subject ID for backups and backup_tasks; VM/container ID for snapshots, resource_disks)",
},
"guest_id": {
Type: "string",
Description: "Filter by guest ID (for snapshots, backup_tasks)",
},
"vm_id": {
Type: "string",
Description: "Filter by VM ID (for replication)",
},
"instance": {
Type: "string",
Description: "Filter by Proxmox/PBS instance",
},
"node": {
Type: "string",
Description: "Filter by node name",
},
"host": {
Type: "string",
Description: "Filter by host (for raid, ceph_details)",
},
"cluster": {
Type: "string",
Description: "Filter by Ceph cluster name",
},
"job_type": {
Type: "string",
Description: "Filter PBS jobs by type: backup, sync, verify, prune, garbage",
Enum: []string{"backup", "sync", "verify", "prune", "garbage"},
},
"state": {
Type: "string",
Description: "Filter RAID arrays by state: clean, degraded, rebuilding",
},
"status": {
Type: "string",
Description: "Filter backup tasks by status: ok, error",
},
"resource_type": {
Type: "string",
Description: "Filter by type: vm or system-container (for resource_disks)",
},
"min_usage": {
Type: "number",
Description: "Only show resources with disk usage above this percentage (for resource_disks)",
},
"limit": {
Type: "integer",
Description: "Maximum number of results (default: 100)",
},
"offset": {
Type: "integer",
Description: "Number of results to skip",
},
},
Required: []string{"type"},
},
},
Handler: func(ctx context.Context, exec *PulseToolExecutor, args map[string]interface{}) (CallToolResult, error) {
return exec.executeStorage(ctx, args)
},
Governance: ToolGovernance{
ActionMode: ToolActionRead,
ApprovalPolicy: ToolApprovalScopeOnly,
ApprovalSummary: "no approval required",
Summary: "Reads storage, backup, recovery, Ceph, RAID, and disk-health state without changing infrastructure.",
},
})
}
// executeStorage routes to the appropriate storage handler based on type
func (e *PulseToolExecutor) executeStorage(ctx context.Context, args map[string]interface{}) (CallToolResult, error) {
storageType, _ := args["type"].(string)
switch storageType {
case "pools":
return e.executeListStorage(ctx, args)
case "backups":
return e.executeListBackups(ctx, args)
case "backup_tasks":
return e.executeListBackupTasks(ctx, args)
case "snapshots":
return e.executeListSnapshots(ctx, args)
case "ceph":
return e.executeGetCephStatus(ctx, args)
case "ceph_details":
return e.executeGetHostCephDetails(ctx, args)
case "replication":
return e.executeGetReplication(ctx, args)
case "pbs_jobs":
return e.executeListPBSJobs(ctx, args)
case "raid":
return e.executeGetHostRAIDStatus(ctx, args)
case "disk_health":
return e.executeGetDiskHealth(ctx, args)
case "resource_disks":
return e.executeGetResourceDisks(ctx, args)
default:
return NewErrorResult(fmt.Errorf("unknown type: %s. Use: pools, backups, backup_tasks, snapshots, ceph, ceph_details, replication, pbs_jobs, raid, disk_health, resource_disks", storageType)), nil
}
}
func (e *PulseToolExecutor) executeListBackups(ctx context.Context, args map[string]interface{}) (CallToolResult, error) {
resourceID, _ := args["resource_id"].(string)
limit := intArg(args, "limit", 100)
offset := intArg(args, "offset", 0)
if limit <= 0 {
limit = recovery.DefaultListPageLimit
}
if limit > recovery.MaxListPageLimit {
limit = recovery.MaxListPageLimit
}
if offset < 0 {
offset = 0
}
if e.recoveryPointsProvider == nil {
return NewErrorResult(fmt.Errorf("backup inventory unavailable: recovery points provider not configured")), nil
}
response := EmptyBackupsResponse()
response.Pagination = &PaginationInfo{Limit: limit, Offset: offset}
ctx, cancel := context.WithTimeout(ctx, 5*time.Second)
defer cancel()
// Translate the tool's global offset into the canonical store's pages.
// At most two pages are needed, even for offsets beyond the first 4,000
// records. Do not scan or paginate each provider's legacy lists separately.
const pageLimit = recovery.MaxListPageLimit
page, skip := offset/pageLimit+1, offset%pageLimit
for len(response.Points) < limit {
points, total, err := e.recoveryPointsProvider.ListPoints(ctx, recovery.ListPointsOptions{
Kind: recovery.KindBackup, SubjectResourceID: strings.TrimSpace(resourceID),
Page: page, Limit: pageLimit,
})
if err != nil {
return NewErrorResult(err), nil
}
response.Pagination.Total = total
if skip >= len(points) {
break
}
end := skip + min(limit-len(response.Points), len(points)-skip)
response.Points = append(response.Points, points[skip:end]...)
if end < len(points) || len(points) < pageLimit {
break
}
page++
skip = 0
}
return NewJSONResult(response.NormalizeCollections()), nil
}
func (e *PulseToolExecutor) executeListStorage(_ context.Context, args map[string]interface{}) (CallToolResult, error) {
storageID, _ := args["storage_id"].(string)
limit := intArg(args, "limit", 100)
offset := intArg(args, "offset", 0)
response := EmptyStorageResponse()
// Storage pools
count := 0
var storageResources []unifiedresources.Resource
if e.unifiedResourceProvider != nil {
storageResources = e.unifiedResourceProvider.GetByType(unifiedresources.ResourceTypeStorage)
}
for _, r := range storageResources {
if r.Storage == nil {
continue
}
if storageID != "" && r.ID != storageID && r.Name != storageID {
continue
}
if count < offset {
count++
continue
}
if len(response.Pools) >= limit {
break
}
pool := storagePoolSummaryFromResource(r)
response.Pools = append(response.Pools, pool)
count++
}
// Ceph clusters from unified resources
if e.unifiedResourceProvider != nil {
for _, r := range e.unifiedResourceProvider.GetByType(unifiedresources.ResourceTypeCeph) {
if r.Ceph == nil {
continue
}
c := r.Ceph
usedBytes, totalBytes := cephBytesFromResource(r)
usagePercent := 0.0
if totalBytes > 0 {
usagePercent = float64(usedBytes) / float64(totalBytes) * 100
}
response.CephClusters = append(response.CephClusters, CephClusterSummary{
Name: r.Name,
Health: c.HealthStatus,
HealthMessage: c.HealthMessage,
UsagePercent: usagePercent,
UsedTB: float64(usedBytes) / (1024 * 1024 * 1024 * 1024),
TotalTB: float64(totalBytes) / (1024 * 1024 * 1024 * 1024),
NumOSDs: c.NumOSDs,
NumOSDsUp: c.NumOSDsUp,
NumOSDsIn: c.NumOSDsIn,
NumMons: c.NumMons,
NumMgrs: c.NumMgrs,
})
}
}
return NewJSONResult(response.NormalizeCollections()), nil
}
func storagePoolSummaryFromResource(r unifiedresources.Resource) StoragePoolSummary {
var (
poolType string
content string
shared bool
node string
instance string
usedBytes int64
totalBytes int64
usagePercent float64
)
if r.Storage != nil {
poolType = r.Storage.Type
content = r.Storage.Content
shared = r.Storage.Shared
if content == "" && len(r.Storage.ContentTypes) > 0 {
content = strings.Join(r.Storage.ContentTypes, ",")
}
}
if r.Proxmox != nil {
node = r.Proxmox.NodeName
instance = r.Proxmox.Instance
}
if r.Metrics != nil && r.Metrics.Disk != nil {
if r.Metrics.Disk.Used != nil {
usedBytes = *r.Metrics.Disk.Used
}
if r.Metrics.Disk.Total != nil {
totalBytes = *r.Metrics.Disk.Total
}
usagePercent = r.Metrics.Disk.Percent
}
if usagePercent == 0 && totalBytes > 0 {
usagePercent = float64(usedBytes) / float64(totalBytes) * 100
}
freeBytes := int64(0)
if totalBytes > usedBytes {
freeBytes = totalBytes - usedBytes
}
// Enabled is the source's configuration flag, so an unavailable storage
// (Proxmox active=0) must not read as administratively disabled. Active
// also needs the row itself to be up: PBS datastores report Active even
// while unavailable, and an offline row is not usable whatever its flag.
active := r.Status != unifiedresources.StatusOffline
enabled := active
if r.Storage != nil {
enabled = r.Storage.Enabled
active = active && r.Storage.Active
}
id := r.ID
if id == "" {
id = r.Name
}
name := r.Name
if name == "" {
name = id
}
return StoragePoolSummary{
ID: id,
Name: name,
Node: node,
Instance: instance,
Type: poolType,
Status: string(r.Status),
Enabled: enabled,
Active: active,
UsagePercent: usagePercent,
UsedGB: float64(usedBytes) / (1024 * 1024 * 1024),
TotalGB: float64(totalBytes) / (1024 * 1024 * 1024),
FreeGB: float64(freeBytes) / (1024 * 1024 * 1024),
Content: content,
Shared: shared,
}
}
// cephBytesFromResource extracts used/total bytes from a unified Ceph resource.
// It prefers the Metrics.Disk values (which carry absolute bytes), falling back
// to summing pool-level data from CephMeta.
func cephBytesFromResource(r unifiedresources.Resource) (usedBytes, totalBytes int64) {
if r.Metrics != nil && r.Metrics.Disk != nil && r.Metrics.Disk.Used != nil && r.Metrics.Disk.Total != nil {
return *r.Metrics.Disk.Used, *r.Metrics.Disk.Total
}
if r.Ceph != nil {
for _, p := range r.Ceph.Pools {
usedBytes += p.StoredBytes
totalBytes += p.StoredBytes + p.AvailableBytes
}
}
return
}
func (e *PulseToolExecutor) executeGetDiskHealth(_ context.Context, _ map[string]interface{}) (CallToolResult, error) {
if e.diskHealthProvider == nil {
return NewTextResult("Disk health information not available."), nil
}
response := EmptyDiskHealthResponse()
// SMART and RAID data from host agents
if e.diskHealthProvider != nil {
hosts := e.diskHealthProvider.GetHosts()
for _, host := range hosts {
hostHealth := HostDiskHealth{
Hostname: toolHostLabel(host),
}
// SMART data
if sensors := host.Sensors(); sensors != nil {
for _, disk := range sensors.SMART {
temperature := SplitDiskTemperature(disk.Temperature, disk.Collection)
hostHealth.SMART = append(hostHealth.SMART, SMARTDiskSummary{
Device: disk.Device,
Model: disk.Model,
Health: disk.Health,
Temperature: temperature.Collected,
LastKnownTemperature: temperature.LastKnown,
LastKnownTemperatureReason: temperature.Reason,
})
}
}
// RAID arrays
for _, raid := range host.RAID() {
hostHealth.RAID = append(hostHealth.RAID, RAIDArraySummary{
Device: raid.Device,
Level: raid.Level,
State: raid.State,
ActiveDevices: raid.ActiveDevices,
WorkingDevices: raid.WorkingDevices,
FailedDevices: raid.FailedDevices,
SpareDevices: raid.SpareDevices,
RebuildPercent: raid.RebuildPercent,
})
}
// Ceph from agent
if ceph := host.Ceph(); ceph != nil {
hostHealth.Ceph = &CephStatusSummary{
Health: ceph.Health.Status,
NumOSDs: ceph.OSDMap.NumOSDs,
NumOSDsUp: ceph.OSDMap.NumUp,
NumOSDsIn: ceph.OSDMap.NumIn,
NumPGs: ceph.PGMap.NumPGs,
UsagePercent: ceph.PGMap.UsagePercent,
}
}
// Only add if there's data
if len(hostHealth.SMART) > 0 || len(hostHealth.RAID) > 0 || hostHealth.Ceph != nil {
response.Hosts = append(response.Hosts, hostHealth)
}
}
}
return NewJSONResult(response.NormalizeCollections()), nil
}
// executeGetCephStatus returns Ceph cluster status
func (e *PulseToolExecutor) executeGetCephStatus(_ context.Context, args map[string]interface{}) (CallToolResult, error) {
clusterFilter, _ := args["cluster"].(string)
type CephSummary struct {
Name string `json:"name"`
Health string `json:"health"`
Details map[string]interface{} `json:"details,omitempty"`
}
var results []CephSummary
if e.unifiedResourceProvider != nil {
resources := e.unifiedResourceProvider.GetByType(unifiedresources.ResourceTypeCeph)
for _, r := range resources {
if r.Ceph == nil {
continue
}
if clusterFilter != "" && r.Name != clusterFilter {
continue
}
c := r.Ceph
summary := CephSummary{
Name: r.Name,
Health: c.HealthStatus,
Details: make(map[string]interface{}),
}
if c.HealthMessage != "" {
summary.Details["health_message"] = c.HealthMessage
}
if c.NumOSDs > 0 {
summary.Details["osd_count"] = c.NumOSDs
summary.Details["osds_up"] = c.NumOSDsUp
summary.Details["osds_in"] = c.NumOSDsIn
summary.Details["osds_down"] = c.NumOSDs - c.NumOSDsUp
}
if c.NumMons > 0 {
summary.Details["monitors"] = c.NumMons
}
usedBytes, totalBytes := cephBytesFromResource(r)
if totalBytes > 0 {
summary.Details["total_bytes"] = totalBytes
summary.Details["used_bytes"] = usedBytes
summary.Details["available_bytes"] = totalBytes - usedBytes
usagePercent := float64(usedBytes) / float64(totalBytes) * 100
summary.Details["usage_percent"] = usagePercent
}
if len(c.Pools) > 0 {
summary.Details["pools"] = c.Pools
}
results = append(results, summary)
}
}
if len(results) == 0 {
if clusterFilter != "" {
return NewTextResult(fmt.Sprintf("Ceph cluster '%s' not found.", clusterFilter)), nil
}
return NewTextResult("No Ceph clusters found. Ceph may not be configured or data is not yet available."), nil
}
output, _ := json.MarshalIndent(results, "", " ")
return NewTextResult(string(output)), nil
}
// executeGetReplication returns replication job status
func (e *PulseToolExecutor) executeGetReplication(_ context.Context, args map[string]interface{}) (CallToolResult, error) {
vmFilter, _ := args["vm_id"].(string)
if e.replicationProvider == nil {
return NewTextResult("No replication jobs found. Replication may not be configured."), nil
}
jobs := e.replicationProvider.GetReplicationJobs()
if len(jobs) == 0 {
return NewTextResult("No replication jobs found. Replication may not be configured."), nil
}
type ReplicationSummary struct {
ID string `json:"id"`
GuestID int `json:"guest_id"`
GuestName string `json:"guest_name,omitempty"`
GuestType string `json:"guest_type,omitempty"`
SourceNode string `json:"source_node,omitempty"`
TargetNode string `json:"target_node"`
Schedule string `json:"schedule,omitempty"`
Status string `json:"status"`
LastSync string `json:"last_sync,omitempty"`
NextSync string `json:"next_sync,omitempty"`
LastDuration string `json:"last_duration,omitempty"`
Error string `json:"error,omitempty"`
}
var results []ReplicationSummary
for _, job := range jobs {
if vmFilter != "" && fmt.Sprintf("%d", job.GuestID) != vmFilter {
continue
}
summary := ReplicationSummary{
ID: job.ID,
GuestID: job.GuestID,
GuestName: job.GuestName,
GuestType: job.GuestType,
SourceNode: job.SourceNode,
TargetNode: job.TargetNode,
Schedule: job.Schedule,
Status: job.Status,
}
if job.LastSyncTime != nil {
summary.LastSync = job.LastSyncTime.Format("2006-01-02 15:04:05")
}
if job.NextSyncTime != nil {
summary.NextSync = job.NextSyncTime.Format("2006-01-02 15:04:05")
}
if job.LastSyncDurationHuman != "" {
summary.LastDuration = job.LastSyncDurationHuman
}
if job.Error != "" {
summary.Error = job.Error
}
results = append(results, summary)
}
if len(results) == 0 && vmFilter != "" {
return NewTextResult(fmt.Sprintf("No replication jobs found for VM %s.", vmFilter)), nil
}
output, _ := json.MarshalIndent(results, "", " ")
return NewTextResult(string(output)), nil
}
// containsAny checks if s contains any of the substrings (case-insensitive)
func containsAny(s string, substrs ...string) bool {
lower := strings.ToLower(s)
for _, sub := range substrs {
if strings.Contains(lower, strings.ToLower(sub)) {
return true
}
}
return false
}
func (e *PulseToolExecutor) legacyPVESnapshotPoints() ([]recovery.RecoveryPoint, int) {
if e.backupProvider != nil {
backups := e.backupProvider.GetBackups()
return proxmoxrecoverymapper.FromPVEGuestSnapshots(backups.PVE.GuestSnapshots, nil), len(backups.PVE.GuestSnapshots)
}
return nil, 0
}
func (e *PulseToolExecutor) legacyPVEBackupTaskPoints() ([]recovery.RecoveryPoint, int) {
if e.backupProvider != nil {
backups := e.backupProvider.GetBackups()
return proxmoxrecoverymapper.FromPVEBackupTasks(backups.PVE.BackupTasks, nil), len(backups.PVE.BackupTasks)
}
return nil, 0
}
func recoveryPointDetailString(p recovery.RecoveryPoint, key string) string {
if p.Details == nil {
return ""
}
v, ok := p.Details[key]
if !ok || v == nil {
return ""
}
if s, ok := v.(string); ok {
return strings.TrimSpace(s)
}
return ""
}
func recoveryPointDetailInt(p recovery.RecoveryPoint, key string) int {
if p.Details == nil {
return 0
}
v, ok := p.Details[key]
if !ok || v == nil {
return 0
}
switch n := v.(type) {
case int:
return n
case int64:
return int(n)
case float64:
return int(n)
case json.Number:
i, _ := n.Int64()
return int(i)
default:
return 0
}
}
func recoveryPointDetailBool(p recovery.RecoveryPoint, key string) bool {
if p.Details == nil {
return false
}
v, ok := p.Details[key]
if !ok || v == nil {
return false
}
b, ok := v.(bool)
return ok && b
}
func recoveryPointDisplayString(p recovery.RecoveryPoint, value func(*recovery.RecoveryPointDisplay) string) string {
if p.Display == nil {
return ""
}
return strings.TrimSpace(value(p.Display))
}
func parseRecoveryPointVMID(value string) int {
vmid, err := strconv.Atoi(strings.TrimSpace(value))
if err != nil || vmid <= 0 {
return 0
}
return vmid
}
func recoveryPointCanonicalGuestType(p recovery.RecoveryPoint) string {
raw := recoveryPointDisplayString(p, func(display *recovery.RecoveryPointDisplay) string { return display.ItemType })
if raw == "" && p.SubjectRef != nil {
raw = strings.TrimSpace(p.SubjectRef.Type)
}
if raw == "" {
raw = recoveryPointDetailString(p, "type")
}
switch recovery.NormalizeRecoveryItemType(raw) {
case "vm":
return "vm"
case "system-container":
return "lxc"
default:
return strings.TrimSpace(raw)
}
}
func recoveryPointCanonicalInstance(p recovery.RecoveryPoint) string {
if value := recoveryPointDisplayString(p, func(display *recovery.RecoveryPointDisplay) string { return display.ClusterLabel }); value != "" {
return value
}
if p.SubjectRef != nil {
if value := strings.TrimSpace(p.SubjectRef.Namespace); value != "" {
return value
}
}
return recoveryPointDetailString(p, "instance")
}
func recoveryPointCanonicalNode(p recovery.RecoveryPoint) string {
if value := recoveryPointDisplayString(p, func(display *recovery.RecoveryPointDisplay) string { return display.NodeHostLabel }); value != "" {
return value
}
if p.SubjectRef != nil {
if value := strings.TrimSpace(p.SubjectRef.Class); value != "" {
return value
}
}
return recoveryPointDetailString(p, "node")
}
func recoveryPointCanonicalVMID(p recovery.RecoveryPoint) int {
if value := parseRecoveryPointVMID(recoveryPointDisplayString(p, func(display *recovery.RecoveryPointDisplay) string { return display.EntityIDLabel })); value > 0 {
return value
}
if p.SubjectRef != nil {
if value := parseRecoveryPointVMID(p.SubjectRef.Name); value > 0 {
return value
}
if value := parseRecoveryPointVMID(p.SubjectRef.ID); value > 0 {
return value
}
}
return recoveryPointDetailInt(p, "vmid")
}
func recoveryPointCanonicalSnapshotName(p recovery.RecoveryPoint, trimPrefix func(string) string) string {
if value := recoveryPointDetailString(p, "snapshotName"); value != "" {
return value
}
if value := recoveryPointDisplayString(p, func(display *recovery.RecoveryPointDisplay) string { return display.DetailsSummary }); value != "" {
return value
}
return trimPrefix(p.ID)
}
func recoveryPointCanonicalTaskStatus(p recovery.RecoveryPoint) string {
if value := recoveryPointDetailString(p, "status"); value != "" {
return value
}
switch p.Outcome {
case recovery.OutcomeSuccess:
return "OK"
case recovery.OutcomeFailed:
return "ERROR"
case recovery.OutcomeWarning:
return "WARNING"
case recovery.OutcomeRunning:
return "RUNNING"
default:
return "UNKNOWN"
}
}
func recoveryPointCanonicalTaskError(p recovery.RecoveryPoint) string {
if value := recoveryPointDetailString(p, "error"); value != "" {
return value
}
if p.Outcome == recovery.OutcomeFailed || p.Outcome == recovery.OutcomeWarning {
return recoveryPointDisplayString(p, func(display *recovery.RecoveryPointDisplay) string { return display.DetailsSummary })
}
return ""
}
func backupTaskMatchesStatus(filter, status string, outcome recovery.Outcome) bool {
if filter == "" || strings.EqualFold(filter, status) {
return true
}
switch strings.ToLower(strings.TrimSpace(filter)) {
case "ok", "success":
return outcome == recovery.OutcomeSuccess
case "error", "failed":
return outcome == recovery.OutcomeFailed
default:
return false
}
}
func (e *PulseToolExecutor) executeListSnapshots(ctx context.Context, args map[string]interface{}) (CallToolResult, error) {
if e.backupProvider == nil && e.recoveryPointsProvider == nil {
return NewTextResult("State provider not available."), nil
}
guestIDFilter, _ := args["guest_id"].(string)
instanceFilter, _ := args["instance"].(string)
limit := intArg(args, "limit", 100)
offset := intArg(args, "offset", 0)
// Build VM name map for enrichment
vmNames := make(map[int]string)
if rs, err := e.readStateForControl(); err == nil {
for _, w := range rs.Workloads() {
if w.VMID() > 0 && w.Name() != "" {
// Best-effort: VMID collisions across instances are possible; this matches legacy behavior.
if _, exists := vmNames[w.VMID()]; !exists {
vmNames[w.VMID()] = w.Name()
}
}
}
}
var snapshots []SnapshotSummary
filteredCount := 0
totalCount := 0
trimPrefix := func(id string) string {
id = strings.TrimSpace(id)
if strings.HasPrefix(id, "pve-snapshot:") {
return strings.TrimPrefix(id, "pve-snapshot:")
}
return id
}
if e.recoveryPointsProvider != nil {
const pageLimit = 200
const maxPages = 20
ctx, cancel := context.WithTimeout(ctx, 5*time.Second)
defer cancel()
matchedIndex := 0
for page := 1; page <= maxPages; page++ {
points, total, err := e.recoveryPointsProvider.ListPoints(ctx, recovery.ListPointsOptions{
Provider: recovery.ProviderProxmoxPVE,
Kind: recovery.KindSnapshot,
Page: page,
Limit: pageLimit,
})
if err != nil {
return NewErrorResult(err), nil
}
if page == 1 {
totalCount = total
}
if len(points) == 0 {
break
}
for _, p := range points {
if !strings.HasPrefix(strings.TrimSpace(p.ID), "pve-snapshot:") {
continue
}
vmid := recoveryPointCanonicalVMID(p)
instance := recoveryPointCanonicalInstance(p)
if guestIDFilter != "" && strconv.Itoa(vmid) != guestIDFilter {
continue
}
if instanceFilter != "" && instance != instanceFilter {
continue
}
filteredCount++
if matchedIndex < offset {
matchedIndex++
continue
}
if len(snapshots) >= limit {
matchedIndex++
continue
}
node := recoveryPointCanonicalNode(p)
guestType := recoveryPointCanonicalGuestType(p)
snapshotName := recoveryPointCanonicalSnapshotName(p, trimPrefix)
description := recoveryPointDetailString(p, "description")
var ts time.Time
if p.CompletedAt != nil {
ts = p.CompletedAt.UTC()
} else if p.StartedAt != nil {
ts = p.StartedAt.UTC()
} else {
ts = time.Time{}
}
size := int64(0)
if p.SizeBytes != nil {
size = *p.SizeBytes
}
snapshots = append(snapshots, SnapshotSummary{
ID: trimPrefix(p.ID),
VMID: vmid,
VMName: vmNames[vmid],
Type: guestType,
Node: node,
Instance: instance,
SnapshotName: snapshotName,
Description: description,
Time: ts,
VMState: recoveryPointDetailBool(p, "vmState"),
SizeBytes: size,
})
matchedIndex++
}
if len(snapshots) >= limit && matchedIndex >= offset+limit {
break
}
}
} else {
// Legacy fallback: normalize snapshot data into recovery points so
// both paths share the same extraction behavior.
points, total := e.legacyPVESnapshotPoints()
totalCount = total
matchedIndex := 0
for _, p := range points {
if !strings.HasPrefix(strings.TrimSpace(p.ID), "pve-snapshot:") {
continue
}
vmid := recoveryPointCanonicalVMID(p)
instance := recoveryPointCanonicalInstance(p)
// Apply filters
if guestIDFilter != "" && strconv.Itoa(vmid) != guestIDFilter {
continue
}
if instanceFilter != "" && instance != instanceFilter {
continue
}
filteredCount++
// Apply pagination
if matchedIndex < offset {
matchedIndex++
continue
}
if len(snapshots) >= limit {
matchedIndex++
continue
}
node := recoveryPointCanonicalNode(p)
guestType := recoveryPointCanonicalGuestType(p)
snapshotName := recoveryPointCanonicalSnapshotName(p, trimPrefix)
description := recoveryPointDetailString(p, "description")
var ts time.Time
if p.CompletedAt != nil {
ts = p.CompletedAt.UTC()
} else if p.StartedAt != nil {
ts = p.StartedAt.UTC()
}
size := int64(0)
if p.SizeBytes != nil {
size = *p.SizeBytes
}
snapshots = append(snapshots, SnapshotSummary{
ID: trimPrefix(p.ID),
VMID: vmid,
VMName: vmNames[vmid],
Type: guestType,
Node: node,
Instance: instance,
SnapshotName: snapshotName,
Description: description,
Time: ts,
VMState: recoveryPointDetailBool(p, "vmState"),
SizeBytes: size,
})
matchedIndex++
}
}
if snapshots == nil {
snapshots = []SnapshotSummary{}
}
response := EmptySnapshotsResponse()
response.Snapshots = snapshots
response.Total = totalCount
response.Filtered = filteredCount
return NewJSONResult(response.NormalizeCollections()), nil
}
func (e *PulseToolExecutor) executeListPBSJobs(_ context.Context, args map[string]interface{}) (CallToolResult, error) {
if e.backupProvider == nil {
return NewTextResult("Backup provider not available."), nil
}
instanceFilter, _ := args["instance"].(string)
jobTypeFilter, _ := args["job_type"].(string)
pbsInstances := e.backupProvider.GetPBSInstances()
if len(pbsInstances) == 0 {
return NewTextResult("No PBS instances found. PBS monitoring may not be configured."), nil
}
var jobs []PBSJobSummary
for _, pbs := range pbsInstances {
if instanceFilter != "" && pbs.ID != instanceFilter && pbs.Name != instanceFilter {
continue
}
// Backup jobs
if jobTypeFilter == "" || jobTypeFilter == "backup" {
for _, job := range pbs.BackupJobs {
jobs = append(jobs, PBSJobSummary{
ID: job.ID,
Type: "backup",
Store: job.Store,
Status: job.Status,
LastRun: job.LastBackup,
NextRun: job.NextRun,
Error: job.Error,
VMID: job.VMID,
})
}
}
// Sync jobs
if jobTypeFilter == "" || jobTypeFilter == "sync" {
for _, job := range pbs.SyncJobs {
jobs = append(jobs, PBSJobSummary{
ID: job.ID,
Type: "sync",
Store: job.Store,
Status: job.Status,
LastRun: job.LastSync,
NextRun: job.NextRun,
Error: job.Error,
Remote: job.Remote,
})
}
}
// Verify jobs
if jobTypeFilter == "" || jobTypeFilter == "verify" {
for _, job := range pbs.VerifyJobs {
jobs = append(jobs, PBSJobSummary{
ID: job.ID,
Type: "verify",
Store: job.Store,
Status: job.Status,
LastRun: job.LastVerify,
NextRun: job.NextRun,
Error: job.Error,
})
}
}
// Prune jobs
if jobTypeFilter == "" || jobTypeFilter == "prune" {
for _, job := range pbs.PruneJobs {
jobs = append(jobs, PBSJobSummary{
ID: job.ID,
Type: "prune",
Store: job.Store,
Status: job.Status,
LastRun: job.LastPrune,
NextRun: job.NextRun,
Error: job.Error,
})
}
}
// Garbage jobs
if jobTypeFilter == "" || jobTypeFilter == "garbage" {
for _, job := range pbs.GarbageJobs {
jobs = append(jobs, PBSJobSummary{
ID: job.ID,
Type: "garbage",
Store: job.Store,
Status: job.Status,
LastRun: job.LastGarbage,
NextRun: job.NextRun,
Error: job.Error,
RemovedBytes: job.RemovedBytes,
})
}
}
}
if jobs == nil {
jobs = []PBSJobSummary{}
}
response := EmptyPBSJobsResponse()
response.Instance = instanceFilter
response.Jobs = jobs
response.Total = len(jobs)
return NewJSONResult(response.NormalizeCollections()), nil
}
func (e *PulseToolExecutor) executeListBackupTasks(ctx context.Context, args map[string]interface{}) (CallToolResult, error) {
if e.backupProvider == nil && e.recoveryPointsProvider == nil {
return NewTextResult("State provider not available."), nil
}
instanceFilter, _ := args["instance"].(string)
guestIDFilter, _ := args["guest_id"].(string)
resourceIDFilter, _ := args["resource_id"].(string)
statusFilter, _ := args["status"].(string)
limit := intArg(args, "limit", 50)
// Build VM name map
vmNames := make(map[int]string)
if rs, err := e.readStateForControl(); err == nil {
for _, w := range rs.Workloads() {
if w.VMID() > 0 && w.Name() != "" {
if _, exists := vmNames[w.VMID()]; !exists {
vmNames[w.VMID()] = w.Name()
}
}
}
}
var tasks []BackupTaskDetail
filteredCount := 0
totalCount := 0
trimPrefix := func(id string) string {
id = strings.TrimSpace(id)
if strings.HasPrefix(id, "pve-task:") {
return strings.TrimPrefix(id, "pve-task:")
}
return id
}
if e.recoveryPointsProvider != nil {
const pageLimit = 200
const maxPages = 20
ctx, cancel := context.WithTimeout(ctx, 5*time.Second)
defer cancel()
for page := 1; page <= maxPages; page++ {
points, _, err := e.recoveryPointsProvider.ListPoints(ctx, recovery.ListPointsOptions{
Provider: recovery.ProviderProxmoxPVE,
// Task rows are execution evidence (KindOther), not backup
// artifacts. The prefix below also accepts older stored task kinds.
SubjectResourceID: resourceIDFilter,
Page: page,
Limit: pageLimit,
})
if err != nil {
return NewErrorResult(err), nil
}
if len(points) == 0 {
break
}
for _, p := range points {
if !strings.HasPrefix(strings.TrimSpace(p.ID), "pve-task:") {
continue
}
if resourceIDFilter != "" && p.SubjectResourceID != resourceIDFilter {
continue
}
totalCount++
instance := recoveryPointCanonicalInstance(p)
node := recoveryPointCanonicalNode(p)
vmid := recoveryPointCanonicalVMID(p)
status := recoveryPointCanonicalTaskStatus(p)
taskType := recoveryPointCanonicalGuestType(p)
errText := recoveryPointCanonicalTaskError(p)
// Apply filters
if instanceFilter != "" && instance != instanceFilter {
continue
}
if guestIDFilter != "" && strconv.Itoa(vmid) != guestIDFilter {
continue
}
if !backupTaskMatchesStatus(statusFilter, status, p.Outcome) {
continue
}
filteredCount++
if len(tasks) >= limit {
continue
}
started := time.Time{}
if p.StartedAt != nil {
started = p.StartedAt.UTC()
}
ended := time.Time{}
if p.CompletedAt != nil {
ended = p.CompletedAt.UTC()
}
size := int64(0)
if p.SizeBytes != nil {
size = *p.SizeBytes
}
tasks = append(tasks, BackupTaskDetail{
ID: trimPrefix(p.ID),
VMID: vmid,
VMName: vmNames[vmid],
Node: node,
Instance: instance,
Type: taskType,
Status: status,
StartTime: started,
EndTime: ended,
SizeBytes: size,
Error: errText,
})
}
if len(tasks) >= limit {
break
}
}
} else {
// Legacy fallback: normalize backup-task data into recovery points so
// both paths share the same extraction behavior.
points, total := e.legacyPVEBackupTaskPoints()
totalCount = total
for _, p := range points {
if !strings.HasPrefix(strings.TrimSpace(p.ID), "pve-task:") {
continue
}
if resourceIDFilter != "" && p.SubjectResourceID != resourceIDFilter {
continue
}
instance := recoveryPointCanonicalInstance(p)
node := recoveryPointCanonicalNode(p)
vmid := recoveryPointCanonicalVMID(p)
status := recoveryPointCanonicalTaskStatus(p)
taskType := recoveryPointCanonicalGuestType(p)
errText := recoveryPointCanonicalTaskError(p)
// Apply filters
if instanceFilter != "" && instance != instanceFilter {
continue
}
if guestIDFilter != "" && strconv.Itoa(vmid) != guestIDFilter {
continue
}
if !backupTaskMatchesStatus(statusFilter, status, p.Outcome) {
continue
}
filteredCount++
if len(tasks) >= limit {
continue
}
started := time.Time{}
if p.StartedAt != nil {
started = p.StartedAt.UTC()
}
ended := time.Time{}
if p.CompletedAt != nil {
ended = p.CompletedAt.UTC()
}
size := int64(0)
if p.SizeBytes != nil {
size = *p.SizeBytes
}
tasks = append(tasks, BackupTaskDetail{
ID: trimPrefix(p.ID),
VMID: vmid,
VMName: vmNames[vmid],
Node: node,
Instance: instance,
Type: taskType,
Status: status,
StartTime: started,
EndTime: ended,
SizeBytes: size,
Error: errText,
})
}
}
if tasks == nil {
tasks = []BackupTaskDetail{}
}
response := EmptyBackupTasksListResponse()
response.Tasks = tasks
response.Total = totalCount
response.Filtered = filteredCount
return NewJSONResult(response.NormalizeCollections()), nil
}
func (e *PulseToolExecutor) executeGetHostRAIDStatus(_ context.Context, args map[string]interface{}) (CallToolResult, error) {
if e.diskHealthProvider == nil {
return NewTextResult("Disk health provider not available."), nil
}
hostFilter, _ := args["host"].(string)
stateFilter, _ := args["state"].(string)
hosts := e.diskHealthProvider.GetHosts()
var hostSummaries []HostRAIDSummary
for _, host := range hosts {
targetID := toolHostTargetID(host)
hostLabel := toolHostLabel(host)
// Apply host filter
if hostFilter != "" && targetID != hostFilter && host.ID() != hostFilter && toolHostName(host) != hostFilter && hostLabel != hostFilter {
continue
}
// Skip hosts without RAID arrays
raidArrays := host.RAID()
if len(raidArrays) == 0 {
continue
}
var arrays []HostRAIDArraySummary
for _, raid := range raidArrays {
// Apply state filter
if stateFilter != "" && !strings.EqualFold(raid.State, stateFilter) {
continue
}
var devices []HostRAIDDeviceSummary
for _, dev := range raid.Devices {
devices = append(devices, HostRAIDDeviceSummary{
Device: dev.Device,
State: dev.State,
Slot: dev.Slot,
})
}
if devices == nil {
devices = []HostRAIDDeviceSummary{}
}
arrays = append(arrays, HostRAIDArraySummary{
Device: raid.Device,
Name: raid.Name,
Level: raid.Level,
State: raid.State,
RequiredDevices: raid.RequiredDevices,
TotalDevices: raid.TotalDevices,
ActiveDevices: raid.ActiveDevices,
WorkingDevices: raid.WorkingDevices,
FailedDevices: raid.FailedDevices,
SpareDevices: raid.SpareDevices,
UUID: raid.UUID,
RebuildPercent: raid.RebuildPercent,
RebuildSpeed: raid.RebuildSpeed,
Operation: raid.Operation,
Devices: devices,
})
}
if len(arrays) > 0 {
if arrays == nil {
arrays = []HostRAIDArraySummary{}
}
hostSummaries = append(hostSummaries, HostRAIDSummary{
Hostname: hostLabel,
TargetID: targetID,
Arrays: arrays,
})
}
}
if hostSummaries == nil {
hostSummaries = []HostRAIDSummary{}
}
if len(hostSummaries) == 0 {
if hostFilter != "" {
return NewTextResult(fmt.Sprintf("No RAID arrays found for host '%s'.", hostFilter)), nil
}
return NewTextResult("No RAID arrays found across any hosts. RAID monitoring requires host agents to be configured."), nil
}
response := EmptyHostRAIDStatusResponse()
response.Hosts = hostSummaries
response.Total = len(hostSummaries)
return NewJSONResult(response.NormalizeCollections()), nil
}
func (e *PulseToolExecutor) executeGetHostCephDetails(_ context.Context, args map[string]interface{}) (CallToolResult, error) {
if e.diskHealthProvider == nil {
return NewTextResult("Disk health provider not available."), nil
}
hostFilter, _ := args["host"].(string)
hosts := e.diskHealthProvider.GetHosts()
var hostSummaries []HostCephSummary
for _, host := range hosts {
targetID := toolHostTargetID(host)
hostLabel := toolHostLabel(host)
// Apply host filter
if hostFilter != "" && targetID != hostFilter && host.ID() != hostFilter && toolHostName(host) != hostFilter && hostLabel != hostFilter {
continue
}
// Skip hosts without Ceph data
ceph := host.Ceph()
if ceph == nil {
continue
}
// Build health messages from checks and summary
var healthMessages []HostCephHealthMessage
for checkName, check := range ceph.Health.Checks {
msg := check.Message
if msg == "" {
msg = checkName
}
healthMessages = append(healthMessages, HostCephHealthMessage{
Severity: check.Severity,
Message: msg,
})
}
for _, summary := range ceph.Health.Summary {
healthMessages = append(healthMessages, HostCephHealthMessage{
Severity: summary.Severity,
Message: summary.Message,
})
}
// Build monitor summary
var monSummary *HostCephMonSummary
if ceph.MonMap.NumMons > 0 {
var monitors []HostCephMonitorSummary
for _, mon := range ceph.MonMap.Monitors {
monitors = append(monitors, HostCephMonitorSummary{
Name: mon.Name,
Rank: mon.Rank,
Addr: mon.Addr,
Status: mon.Status,
})
}
monSummary = &HostCephMonSummary{
NumMons: ceph.MonMap.NumMons,
Monitors: monitors,
}
}
// Build manager summary
var mgrSummary *HostCephMgrSummary
if ceph.MgrMap.NumMgrs > 0 || ceph.MgrMap.Available {
mgrSummary = &HostCephMgrSummary{
Available: ceph.MgrMap.Available,
NumMgrs: ceph.MgrMap.NumMgrs,
ActiveMgr: ceph.MgrMap.ActiveMgr,
Standbys: ceph.MgrMap.Standbys,
}
}
// Build pool summaries
var pools []HostCephPoolSummary
for _, pool := range ceph.Pools {
pools = append(pools, HostCephPoolSummary{
ID: pool.ID,
Name: pool.Name,
BytesUsed: pool.BytesUsed,
BytesAvailable: pool.BytesAvailable,
Objects: pool.Objects,
PercentUsed: pool.PercentUsed,
})
}
if healthMessages == nil {
healthMessages = []HostCephHealthMessage{}
}
if pools == nil {
pools = []HostCephPoolSummary{}
}
hostSummaries = append(hostSummaries, HostCephSummary{
Hostname: hostLabel,
TargetID: targetID,
FSID: ceph.FSID,
Health: HostCephHealthSummary{
Status: ceph.Health.Status,
Messages: healthMessages,
},
MonMap: monSummary,
MgrMap: mgrSummary,
OSDMap: HostCephOSDSummary{
NumOSDs: ceph.OSDMap.NumOSDs,
NumUp: ceph.OSDMap.NumUp,
NumIn: ceph.OSDMap.NumIn,
NumDown: ceph.OSDMap.NumDown,
NumOut: ceph.OSDMap.NumOut,
},
PGMap: HostCephPGSummary{
NumPGs: ceph.PGMap.NumPGs,
BytesTotal: ceph.PGMap.BytesTotal,
BytesUsed: ceph.PGMap.BytesUsed,
BytesAvailable: ceph.PGMap.BytesAvailable,
UsagePercent: ceph.PGMap.UsagePercent,
DegradedRatio: ceph.PGMap.DegradedRatio,
MisplacedRatio: ceph.PGMap.MisplacedRatio,
ReadBytesPerSec: ceph.PGMap.ReadBytesPerSec,
WriteBytesPerSec: ceph.PGMap.WriteBytesPerSec,
ReadOpsPerSec: ceph.PGMap.ReadOpsPerSec,
WriteOpsPerSec: ceph.PGMap.WriteOpsPerSec,
},
Pools: pools,
CollectedAt: ceph.CollectedAt,
})
}
if hostSummaries == nil {
hostSummaries = []HostCephSummary{}
}
if len(hostSummaries) == 0 {
if hostFilter != "" {
return NewTextResult(fmt.Sprintf("No Ceph data found for host '%s'.", hostFilter)), nil
}
return NewTextResult("No Ceph data found from host agents. Ceph monitoring requires host agents to be configured on Ceph nodes."), nil
}
response := EmptyHostCephDetailsResponse()
response.Hosts = hostSummaries
response.Total = len(hostSummaries)
return NewJSONResult(response.NormalizeCollections()), nil
}
func toolHostTargetID(host *unifiedresources.HostView) string {
if host == nil {
return ""
}
if agentID := strings.TrimSpace(host.AgentID()); agentID != "" {
return agentID
}
return strings.TrimSpace(host.ID())
}
func toolHostName(host *unifiedresources.HostView) string {
if host == nil {
return ""
}
if hostname := strings.TrimSpace(host.Hostname()); hostname != "" {
return hostname
}
return strings.TrimSpace(host.Name())
}
func toolHostLabel(host *unifiedresources.HostView) string {
if name := toolHostName(host); name != "" {
return name
}
return toolHostTargetID(host)
}
// guestDiskView is the read-state view method subset the disk-summary path
// consumes; *unifiedresources.VMView and *unifiedresources.ContainerView both
// satisfy it.
type guestDiskView interface {
comparable
ID() string
SourceID() string
Name() string
VMID() int
Node() string
Instance() string
Disks() []unifiedresources.DiskInfo
}
// appendGuestDiskSummaries appends per-guest disk summaries for one guest
// family (VMs or system containers), applying the shared resource/instance/
// min-usage filters and usage derivation.
func appendGuestDiskSummaries[V guestDiskView](resources []ResourceDisksSummary, guests []V, kind, resourceFilter, instanceFilter string, minUsage float64) []ResourceDisksSummary {
var zero V
for _, g := range guests {
if g == zero {
continue
}
guestVMID := g.VMID()
guestVMIDStr := strconv.Itoa(guestVMID)
guestSourceID := strings.TrimSpace(g.SourceID())
if guestSourceID == "" {
guestSourceID = g.ID()
}
// Apply filters
if resourceFilter != "" && guestSourceID != resourceFilter && guestVMIDStr != resourceFilter {
continue
}
if instanceFilter != "" && g.Instance() != instanceFilter {
continue
}
guestDisks := g.Disks()
// Skip guests without disk data
if len(guestDisks) == 0 {
continue
}
var disks []ResourceDiskInfo
maxUsage := 0.0
for _, disk := range guestDisks {
usage := disk.Usage
if usage <= 0 && disk.Total > 0 {
usage = (float64(disk.Used) / float64(disk.Total)) * 100
}
if usage <= 0 && disk.Used > 0 {
usage = 100
}
if usage > maxUsage {
maxUsage = usage
}
disks = append(disks, ResourceDiskInfo{
Device: disk.Device,
Mountpoint: disk.Mountpoint,
Type: disk.Filesystem,
TotalBytes: disk.Total,
UsedBytes: disk.Used,
FreeBytes: disk.Free,
Usage: usage,
})
}
// Apply min_usage filter
if minUsage > 0 && maxUsage < minUsage {
continue
}
if disks == nil {
disks = []ResourceDiskInfo{}
}
resources = append(resources, ResourceDisksSummary{
ID: guestSourceID,
VMID: guestVMID,
Name: g.Name(),
Type: kind,
Node: g.Node(),
Instance: g.Instance(),
Disks: disks,
})
}
return resources
}
func (e *PulseToolExecutor) executeGetResourceDisks(_ context.Context, args map[string]interface{}) (CallToolResult, error) {
rs, err := e.readStateForControl()
if err != nil {
return NewTextResult("State provider not available."), nil
}
resourceFilter, _ := args["resource_id"].(string)
typeFilter, _ := args["type"].(string)
instanceFilter, _ := args["instance"].(string)
minUsage, _ := args["min_usage"].(float64)
typeFilter = strings.ToLower(strings.TrimSpace(typeFilter))
if typeFilter != "" && typeFilter != "vm" && typeFilter != "system-container" {
return NewErrorResult(fmt.Errorf("unsupported type %q (allowed: vm, system-container)", typeFilter)), nil
}
var resources []ResourceDisksSummary
// Process VMs
if typeFilter == "" || typeFilter == "vm" {
resources = appendGuestDiskSummaries(resources, rs.VMs(), "vm", resourceFilter, instanceFilter, minUsage)
}
// Process containers
if typeFilter == "" || typeFilter == "system-container" {
resources = appendGuestDiskSummaries(resources, rs.Containers(), "system-container", resourceFilter, instanceFilter, minUsage)
}
if resources == nil {
resources = []ResourceDisksSummary{}
}
if len(resources) == 0 {
if resourceFilter != "" {
return NewTextResult(fmt.Sprintf("No disk data found for resource '%s'. Guest agent may not be installed or disk info unavailable.", resourceFilter)), nil
}
return NewTextResult("No disk data available for any VMs or containers. Disk details require guest agents to be installed and running."), nil
}
response := EmptyResourceDisksResponse()
response.Resources = resources
response.Total = len(resources)
return NewJSONResult(response.NormalizeCollections()), nil
}