tutti/services/tuttid/service/agentstatus/codex_runtime_catalog.go

package agentstatus

import (
	"context"
	"crypto/sha256"
	"encoding/hex"
	"errors"
	"strings"
	"time"

	agentproviderbiz "github.com/tutti-os/tutti/services/tuttid/biz/agentprovider"
)

type CodexRuntimeSelectionState string

const (
	CodexRuntimeSelectionUnavailable       CodexRuntimeSelectionState = "unavailable"
	CodexRuntimeSelectionImplicitUnique    CodexRuntimeSelectionState = "implicit_unique"
	CodexRuntimeSelectionSelectionRequired CodexRuntimeSelectionState = "selection_required"
	CodexRuntimeSelectionSelected          CodexRuntimeSelectionState = "selected"
	CodexRuntimeSelectionStale             CodexRuntimeSelectionState = "stale"
)

type CodexRuntimeCatalog struct {
	CapturedAt time.Time
	Provider   string
	Revision   string
	Selection  CodexRuntimeSelection
	Candidates []CodexRuntimeCatalogCandidate
}

type CodexRuntimeCatalogCandidate struct {
	ID              string
	LauncherPath    string
	PackageRoot     string
	Sources         []string
	Version         string
	State           string
	ReasonCode      string
	AppServerReady  bool
	PackageLayoutOK bool
}

type CodexRuntimeSelection struct {
	State        CodexRuntimeSelectionState
	CandidateID  string
	LauncherPath string
	UpdatedAt    *time.Time
}

type SetCodexRuntimeSelectionInput struct {
	Provider    string
	CandidateID string
	Revision    string
}

type codexRuntimeResolvedSelection struct {
	Selection   agentproviderbiz.RuntimeSelection
	Explicit    bool
	Validations []codexRuntimeCandidateValidation
	Index       int
	Launchable  bool
	ReasonCode  string
	State       CodexRuntimeSelectionState
}

var ErrRuntimeCatalogRevisionConflict = errors.New("codex runtime catalog revision conflicts with current discovery")
var ErrRuntimeCandidateNotFound = errors.New("codex runtime candidate not found")
var ErrRuntimeCandidateNotLaunchable = errors.New("codex runtime candidate is not launchable")
var ErrRuntimeSelectionStoreUnavailable = errors.New("codex runtime selection store is unavailable")

// GetCodexRuntimeCatalog discovers and validates every logically distinct
// Codex installation. It is intentionally independent from status caching: a
// user choosing a local executable must see the current filesystem state.
func (s Service) GetCodexRuntimeCatalog(ctx context.Context, provider string) (CodexRuntimeCatalog, error) {
	specs, err := s.registry().Select([]string{provider})
	if err != nil || len(specs) != 1 || !isCodexStatusSpec(specs[0]) {
		return CodexRuntimeCatalog{}, ErrInvalidProvider
	}
	resolved, err := s.resolveCodexRuntimeSelection(ctx, specs[0])
	if err != nil {
		return CodexRuntimeCatalog{}, err
	}
	catalog := codexRuntimeCatalogFromValidations(specs[0].Provider, resolved.Validations)
	catalog.Selection = codexRuntimeCatalogSelection(catalog.Candidates, resolved)
	return catalog, nil
}

func (s Service) SetCodexRuntimeSelection(ctx context.Context, input SetCodexRuntimeSelectionInput) (CodexRuntimeCatalog, error) {
	if s.CodexRuntimeSelectionStore == nil {
		return CodexRuntimeCatalog{}, ErrRuntimeSelectionStoreUnavailable
	}
	catalog, err := s.GetCodexRuntimeCatalog(ctx, input.Provider)
	if err != nil {
		return CodexRuntimeCatalog{}, err
	}
	if strings.TrimSpace(input.CandidateID) == "" || strings.TrimSpace(input.Revision) == "" || input.Revision != catalog.Revision {
		return CodexRuntimeCatalog{}, ErrRuntimeCatalogRevisionConflict
	}
	for _, candidate := range catalog.Candidates {
		if candidate.ID != input.CandidateID {
			continue
		}
		if candidate.State != string(codexRuntimeCandidateValidationReady) {
			return CodexRuntimeCatalog{}, ErrRuntimeCandidateNotLaunchable
		}
		if _, err := s.CodexRuntimeSelectionStore.PutAgentProviderRuntimeSelection(ctx, agentproviderbiz.RuntimeSelection{
			Provider:     catalog.Provider,
			LauncherPath: candidate.LauncherPath,
		}); err != nil {
			return CodexRuntimeCatalog{}, err
		}
		s.invalidateProviderStatus(catalog.Provider)
		return s.GetCodexRuntimeCatalog(ctx, catalog.Provider)
	}
	return CodexRuntimeCatalog{}, ErrRuntimeCandidateNotFound
}

func (s Service) resolveCodexRuntimeSelection(ctx context.Context, spec ProviderSpec) (codexRuntimeResolvedSelection, error) {
	selection, explicit, err := s.codexRuntimeSelection(ctx, spec.Provider)
	if err != nil {
		return codexRuntimeResolvedSelection{}, err
	}
	validations := s.validateCodexRuntimeCandidates(ctx, spec, s.discoverCodexRuntimeCandidates(ctx, spec))
	result := codexRuntimeResolvedSelection{Selection: selection, Explicit: explicit, Validations: validations, Index: -1}
	if !explicit {
		implicit := decideCodexRuntimeImplicitSelection(validations)
		result.Index, result.Launchable, result.ReasonCode, result.State = implicit.CandidateIndex, implicit.Launchable, implicit.ReasonCode, implicit.State
		return result, nil
	}
	for index, validation := range validations {
		if validation.Candidate.LauncherPath != selection.LauncherPath {
			continue
		}
		result.Index = index
		result.Launchable = validation.State == codexRuntimeCandidateValidationReady
		if result.Launchable {
			result.ReasonCode = "codex_runtime_selected_candidate"
			result.State = CodexRuntimeSelectionSelected
		} else {
			result.ReasonCode = "codex_runtime_selection_stale"
			result.State = CodexRuntimeSelectionStale
		}
		return result, nil
	}
	result.ReasonCode = "codex_runtime_selection_stale"
	result.State = CodexRuntimeSelectionStale
	return result, nil
}

func (selection codexRuntimeResolvedSelection) candidate() (codexRuntimeCandidateValidation, bool) {
	if selection.Index < 0 || selection.Index >= len(selection.Validations) {
		return codexRuntimeCandidateValidation{}, false
	}
	return selection.Validations[selection.Index], true
}

func (s Service) codexRuntimeSelection(ctx context.Context, provider string) (agentproviderbiz.RuntimeSelection, bool, error) {
	if s.CodexRuntimeSelectionStore == nil {
		return agentproviderbiz.RuntimeSelection{}, false, ErrRuntimeSelectionStoreUnavailable
	}
	return s.CodexRuntimeSelectionStore.GetAgentProviderRuntimeSelection(ctx, provider)
}

func codexRuntimeCatalogFromValidations(provider string, validations []codexRuntimeCandidateValidation) CodexRuntimeCatalog {
	candidates := make([]CodexRuntimeCatalogCandidate, 0, len(validations))
	for _, validation := range validations {
		candidate := validation.Candidate
		candidates = append(candidates, CodexRuntimeCatalogCandidate{
			ID:              codexRuntimeCandidateID(candidate),
			LauncherPath:    candidate.LauncherPath,
			PackageRoot:     candidate.PackageRoot,
			Sources:         codexRuntimeCandidateSourceStrings(candidate.Sources),
			Version:         validation.Version,
			State:           string(validation.State),
			ReasonCode:      validation.ReasonCode,
			AppServerReady:  validation.Probe.ProtocolReady,
			PackageLayoutOK: codexRuntimePackageLayoutOK(validation.PackageLayout),
		})
	}
	return CodexRuntimeCatalog{
		CapturedAt: time.Now().UTC(),
		Provider:   provider,
		Revision:   codexRuntimeCatalogRevision(candidates),
		Candidates: candidates,
	}
}

func codexRuntimeCandidateSourceStrings(sources []codexRuntimeCandidateSource) []string {
	result := make([]string, 0, len(sources))
	for _, source := range sources {
		result = append(result, string(source))
	}
	return result
}

func codexRuntimePackageLayoutOK(layout CodexPackageLayoutEvidence) bool {
	return (layout.PlatformPackagePresence == CodexPathPresent && layout.PlatformBinaryPresence == CodexPathPresent) ||
		(layout.PlatformPackagePresence == CodexPathNotApplicable && layout.PlatformBinaryPresence == CodexPathNotApplicable)
}

func codexRuntimeCatalogSelection(candidates []CodexRuntimeCatalogCandidate, resolved codexRuntimeResolvedSelection) CodexRuntimeSelection {
	if !resolved.Explicit {
		result := CodexRuntimeSelection{State: resolved.State}
		if resolved.Launchable && resolved.Index >= 0 && resolved.Index < len(candidates) {
			result.CandidateID = candidates[resolved.Index].ID
			result.LauncherPath = candidates[resolved.Index].LauncherPath
		}
		return result
	}
	result := CodexRuntimeSelection{
		State:        CodexRuntimeSelectionStale,
		LauncherPath: resolved.Selection.LauncherPath,
		UpdatedAt:    &resolved.Selection.UpdatedAt,
	}
	for index, candidate := range candidates {
		if candidate.LauncherPath == resolved.Selection.LauncherPath {
			result.State = CodexRuntimeSelectionSelected
			result.CandidateID = candidate.ID
			if !resolved.Launchable || resolved.Index != index {
				result.State = CodexRuntimeSelectionStale
			}
			break
		}
	}
	return result
}

func codexRuntimeCandidateID(candidate codexRuntimeCandidate) string {
	hash := sha256.Sum256([]byte(strings.TrimSpace(candidate.LauncherPath)))
	return "codex-" + hex.EncodeToString(hash[:8])
}

func codexRuntimeCatalogRevision(candidates []CodexRuntimeCatalogCandidate) string {
	hash := sha256.New()
	for _, candidate := range candidates {
		_, _ = hash.Write([]byte(candidate.ID))
		_, _ = hash.Write([]byte{'\n'})
	}
	return hex.EncodeToString(hash.Sum(nil)[:16])
}