Skip to content

armgit / Pulse

Public Imported from GitHub
0

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.

9.5 KB
Raw Blame
package tools

import (
	"strings"
	"time"

	"github.com/rcourtman/pulse-go-rewrite/internal/agentcapabilities"
	"github.com/rcourtman/pulse-go-rewrite/internal/ai/approval"
	unifiedresources "github.com/rcourtman/pulse-go-rewrite/internal/unifiedresources"
	"github.com/rs/zerolog/log"
)

const approvalAuditActor = approval.RequesterPulseAssistant

func actionApprovalRecordForExecution(action unifiedresources.ActionAuditRecord, approvalID, actor string, now time.Time, fallbackOutcome unifiedresources.ApprovalOutcome) unifiedresources.ActionApprovalRecord {
	if fallbackOutcome == "" {
		fallbackOutcome = unifiedresources.OutcomeApproved
	}
	records := approvalRecordsForID(approvalID, &action.Plan)
	if len(records) > 0 {
		record := records[len(records)-1]
		if record.Outcome == "" {
			record.Outcome = fallbackOutcome
		}
		if record.Timestamp.IsZero() {
			record.Timestamp = now
		}
		if strings.TrimSpace(record.Actor) == "" {
			record.Actor = actor
		}
		return record
	}
	actorBinding := legacyApprovalActorBinding(approvalID, actor, action.Request.Actor.OrgID)
	evidence := legacyApprovalEvidence(actorBinding, &action.Plan, fallbackOutcome, now)
	return unifiedresources.ActionApprovalRecord{
		Actor:        actorBinding.SubjectID,
		ActorBinding: actorBinding,
		Method:       evidence.Method,
		Timestamp:    now,
		Outcome:      fallbackOutcome,
		Evidence:     &evidence,
	}
}

// RecordApprovalDecision updates the unified action audit for an approval that
// reached a terminal or pre-execution decision state.
func (e *PulseToolExecutor) RecordApprovalDecision(approvalID string, state unifiedresources.ActionState, actor, message string) {
	var store unifiedresources.ResourceStore
	if e != nil {
		store = e.actionAuditStore
	}
	RecordApprovalDecision(store, approvalID, state, actor, message)
}

// RecordApprovalDecision updates the unified action audit for an approval that
// reached a terminal or pre-execution decision state.
func RecordApprovalDecision(store unifiedresources.ResourceStore, approvalID string, state unifiedresources.ActionState, actor, message string) {
	req := approvalRequestForID(approvalID)
	if req == nil || req.Plan == nil {
		return
	}
	if strings.TrimSpace(actor) == "" {
		actor = approvalDecisionActor(req, approvalAuditActor)
	}
	if strings.TrimSpace(message) == "" {
		message = string(state)
	}
	record := actionAuditRecordFromApproval(req, state, actor)
	record.Approvals = approvalRecordsForID(req.ID, req.Plan)
	if recordApprovalDecisionAtomically(store, req.ID, record, actor) {
		return
	}
	event := unifiedresources.ActionLifecycleEvent{ActionID: req.Plan.ActionID, Timestamp: time.Now().UTC(), State: state, Actor: actor, Message: message}
	if _, _, err := store.CreateActionAudit(record, []unifiedresources.ActionLifecycleEvent{event}); err != nil {
		log.Warn().Err(err).Str("action_id", record.ID).Msg("failed to create action audit for approval decision")
	}
}

func recordApprovalDecisionAtomically(store unifiedresources.ResourceStore, approvalID string, record unifiedresources.ActionAuditRecord, actor string) bool {
	if store == nil {
		return false
	}
	if record.State != unifiedresources.ActionStateApproved && record.State != unifiedresources.ActionStateRejected {
		return false
	}

	current, ok, err := store.GetActionAudit(record.ID)
	if err != nil {
		log.Warn().Err(err).Str("action_id", record.ID).Msg("failed to query action audit before approval decision")
		return false
	}
	if !ok {
		return false
	}
	if current.State != unifiedresources.ActionStatePending {
		if current.State != record.State {
			log.Warn().
				Str("action_id", record.ID).
				Str("current_state", string(current.State)).
				Str("decision_state", string(record.State)).
				Msg("ignoring approval decision for action audit that has already moved past pending")
		}
		return true
	}

	outcome := unifiedresources.OutcomeApproved
	if record.State == unifiedresources.ActionStateRejected {
		outcome = unifiedresources.OutcomeRejected
	}
	approvalRecord := actionApprovalRecordForExecution(current, approvalID, actor, time.Now().UTC(), outcome)
	approvalRecord.Outcome = outcome
	updated, event, err := unifiedresources.ApplyActionDecision(current, approvalRecord, approvalRecord.Timestamp)
	if err != nil {
		log.Warn().Err(err).Str("action_id", record.ID).Msg("failed to normalize approval decision")
		return false
	}
	if err := store.RecordActionDecision(updated, event); err != nil {
		log.Warn().Err(err).Str("action_id", record.ID).Msg("failed to persist approval decision")
		return false
	}
	return true
}

func actionAuditRecordFromApproval(req *approval.ApprovalRequest, state unifiedresources.ActionState, _ string) unifiedresources.ActionAuditRecord {
	now := time.Now().UTC()
	plan := *req.Plan
	if plan.ApprovalPolicy == "" {
		plan.ApprovalPolicy = unifiedresources.ApprovalAdmin
	}
	if plan.ApprovalRequirement.Version == 0 {
		plan.ApprovalRequirement = unifiedresources.ApprovalRequirementForFloor(plan.ApprovalPolicy)
	}
	createdAt := plan.PlannedAt
	if createdAt.IsZero() {
		createdAt = now
	}
	requestID := strings.TrimSpace(plan.RequestID)
	if requestID == "" {
		requestID = strings.TrimSpace(req.ID)
	}
	params := map[string]any{
		"command":    req.Command,
		"targetType": req.TargetType,
		"targetId":   req.TargetID,
		"targetName": req.TargetName,
		"approvalId": req.ID,
	}
	if orgID := strings.TrimSpace(req.OrgID); orgID != "" {
		params["orgId"] = orgID
	}
	requestedBy := approval.RequesterForRequest(req)
	requestActor := unifiedresources.ActionActor{
		SubjectID:    requestedBy,
		Kind:         unifiedresources.ActionActorService,
		CredentialID: "approval-request:" + strings.TrimSpace(req.ID),
		OrgID:        approval.NormalizeOrgID(req.OrgID),
	}
	return unifiedresources.ActionAuditRecord{
		ID:        plan.ActionID,
		CreatedAt: createdAt,
		UpdatedAt: now,
		State:     state,
		Request: unifiedresources.ActionRequest{
			RequestID:      requestID,
			ResourceID:     approvalAuditResourceID(req.TargetType, req.TargetID, req.TargetName),
			CapabilityName: approvalCapabilityForTargetType(req.TargetType),
			Params:         params,
			Reason:         strings.TrimSpace(req.Context),
			RequestedBy:    requestedBy,
			Actor:          requestActor,
		},
		Plan: plan,
	}
}

func approvalRequestForID(approvalID string) *approval.ApprovalRequest {
	approvalID = strings.TrimSpace(approvalID)
	if approvalID == "" {
		return nil
	}
	store := approval.GetStore()
	if store == nil {
		return nil
	}
	req, ok := store.GetApproval(approvalID)
	if !ok || req == nil {
		return nil
	}
	return req
}

func approvalDecisionActor(req *approval.ApprovalRequest, fallback string) string {
	if req != nil {
		if actor := strings.TrimSpace(req.DecidedBy); actor != "" {
			return actor
		}
	}
	if actor := strings.TrimSpace(fallback); actor != "" {
		return actor
	}
	return approvalAuditActor
}

func approvalCapabilityForTargetType(targetType string) string {
	switch strings.ToLower(strings.TrimSpace(targetType)) {
	case "docker":
		return agentcapabilities.PulseDockerToolName
	case "file":
		return agentcapabilities.PulseFileEditToolName
	case "kubernetes":
		return agentcapabilities.PulseKubernetesToolName
	default:
		return agentcapabilities.PulseControlToolName
	}
}

func approvalAuditResourceID(targetType, targetID, targetName string) string {
	targetType = strings.TrimSpace(targetType)
	targetID = strings.TrimSpace(targetID)
	if targetID == "" {
		targetID = strings.TrimSpace(targetName)
	}
	if targetID == "" {
		return strings.TrimSpace(targetType)
	}
	if targetType == "" || strings.Contains(targetID, ":") {
		return targetID
	}
	return targetType + ":" + targetID
}

func approvalRecordsForID(approvalID string, plan *unifiedresources.ActionPlan) []unifiedresources.ActionApprovalRecord {
	approvalID = strings.TrimSpace(approvalID)
	if approvalID == "" {
		return nil
	}
	store := approval.GetStore()
	if store == nil {
		return nil
	}
	req, ok := store.GetApproval(approvalID)
	if !ok || req == nil {
		return nil
	}

	outcome := unifiedresources.OutcomeApproved
	if req.Status == approval.StatusDenied {
		outcome = unifiedresources.OutcomeRejected
	}
	actorBinding := legacyApprovalActorBinding(approvalID, req.DecidedBy, req.OrgID)
	evidence := legacyApprovalEvidence(actorBinding, plan, outcome, approvalTimestamp(req))
	record := unifiedresources.ActionApprovalRecord{
		Actor:        actorBinding.SubjectID,
		ActorBinding: actorBinding,
		Method:       evidence.Method,
		Timestamp:    evidence.IssuedAt,
		Outcome:      outcome,
		Reason:       strings.TrimSpace(req.Context),
		Evidence:     &evidence,
	}
	return []unifiedresources.ActionApprovalRecord{record}
}

func legacyApprovalActorBinding(approvalID, subject, orgID string) unifiedresources.ActionActor {
	return unifiedresources.ActionActor{
		SubjectID:    strings.TrimSpace(subject),
		Kind:         unifiedresources.ActionActorUser,
		CredentialID: "approval-session:" + strings.TrimSpace(approvalID),
		OrgID:        approval.NormalizeOrgID(orgID),
	}
}

func legacyApprovalEvidence(actor unifiedresources.ActionActor, plan *unifiedresources.ActionPlan, outcome unifiedresources.ApprovalOutcome, issuedAt time.Time) unifiedresources.ApprovalEvidence {
	evidence := unifiedresources.ApprovalEvidence{
		Version:  1,
		Method:   unifiedresources.MethodSession,
		Actor:    actor,
		OrgID:    actor.OrgID,
		Outcome:  outcome,
		IssuedAt: issuedAt.UTC(),
	}
	if plan != nil {
		evidence.ActionID = strings.TrimSpace(plan.ActionID)
		evidence.PlanHash = strings.TrimSpace(plan.PlanHash)
	}
	return evidence
}

func approvalTimestamp(req *approval.ApprovalRequest) time.Time {
	if req == nil || req.DecidedAt == nil {
		return time.Now().UTC()
	}
	return req.DecidedAt.UTC()
}