sensorium-mcp 3.0.4 → 3.0.6

package/supervisor/service_restart_windows.go

@@ -1,63 +0,0 @@
-//go:build windows
-
-package main
-
-import (
-	"fmt"
-	"os"
-	"os/exec"
-	"strings"
-)
-
-func scheduleServiceRestartForUpdate(log *Logger) error {
-	scriptFile, err := os.CreateTemp("", "sensorium-supervisor-service-restart-*.cmd")
-	if err != nil {
-		return fmt.Errorf("create service restart helper: %w", err)
-	}
-
-	script := strings.Join([]string{
-		"@echo off",
-		"setlocal",
-		fmt.Sprintf(`sc stop %s >NUL 2>&1`, batchQuote(serviceName)),
-		"timeout /T 2 /NOBREAK >NUL",
-		"set attempts=0",
-		":waitStopped",
-		fmt.Sprintf(`sc query %s | find "STATE" | find "STOPPED" >NUL`, batchQuote(serviceName)),
-		"if not errorlevel 1 goto start",
-		"set /a attempts+=1",
-		"if %attempts% GEQ 10 goto start",
-		"timeout /T 1 /NOBREAK >NUL",
-		"goto waitStopped",
-		":start",
-		"timeout /T 3 /NOBREAK >NUL",
-		fmt.Sprintf(`sc start %s >NUL 2>&1`, batchQuote(serviceName)),
-		"exit /b 0",
-		"",
-	}, "\r\n")
-
-	if _, err := scriptFile.WriteString(script); err != nil {
-		scriptFile.Close()
-		_ = os.Remove(scriptFile.Name())
-		return fmt.Errorf("write service restart helper: %w", err)
-	}
-	if err := scriptFile.Close(); err != nil {
-		_ = os.Remove(scriptFile.Name())
-		return fmt.Errorf("close service restart helper: %w", err)
-	}
-
-	cmd := exec.Command("cmd", "/c", scriptFile.Name())
-	cmd.Env = os.Environ()
-	cmd.Stdin = nil
-	cmd.Stdout = nil
-	cmd.Stderr = nil
-	setSysProcAttr(cmd)
-
-	if err := cmd.Start(); err != nil {
-		_ = os.Remove(scriptFile.Name())
-		return fmt.Errorf("start service restart helper: %w", err)
-	}
-
-	_ = cmd.Process.Release()
-	log.Info("Scheduled detached service restart helper to apply pending supervisor update")
-	return nil
-}

package/supervisor/service_stub.go

@@ -1,15 +0,0 @@
-//go:build !windows
-
-package main
-
-import "errors"
-
-func runAsService() error { return errors.New("not supported on this OS") }
-func installService(_, _, _ string) error {
-	return errors.New("not supported on this OS")
-}
-func uninstallService() error         { return errors.New("not supported on this OS") }
-func startService() error             { return errors.New("not supported on this OS") }
-func stopService() error              { return errors.New("not supported on this OS") }
-func serviceStatus() error            { return errors.New("not supported on this OS") }
-func isWindowsService() (bool, error) { return false, nil }

package/supervisor/service_windows.go

@@ -1,194 +0,0 @@
-//go:build windows
-
-package main
-
-import (
-	"fmt"
-	"os"
-	"path/filepath"
-	"time"
-
-	"golang.org/x/sys/windows/svc"
-	"golang.org/x/sys/windows/svc/mgr"
-)
-
-const serviceName = "SensoriumSupervisor"
-const serviceDisplay = "Sensorium Supervisor"
-const serviceDesc = "Keeps the sensorium-mcp server and agent threads running."
-
-type supervisorService struct{}
-
-func (s *supervisorService) Execute(args []string, r <-chan svc.ChangeRequest, status chan<- svc.Status) (bool, uint32) {
-	status <- svc.Status{State: svc.StartPending}
-
-	done := make(chan error, 1)
-	go func() {
-		done <- runSupervisor(true)
-	}()
-
-	status <- svc.Status{State: svc.Running, Accepts: svc.AcceptStop | svc.AcceptShutdown}
-
-	for {
-		select {
-		case c := <-r:
-			switch c.Cmd {
-			case svc.Interrogate:
-				status <- c.CurrentStatus
-			case svc.Stop, svc.Shutdown:
-				status <- svc.Status{State: svc.StopPending}
-				stopSupervisor()
-				select {
-				case err := <-done:
-					if err != nil {
-						fmt.Fprintf(os.Stderr, "Service shutdown with error: %v\n", err)
-					}
-				case <-time.After(15 * time.Second):
-				}
-				return false, 0
-			}
-		case err := <-done:
-			if err != nil {
-				fmt.Fprintf(os.Stderr, "Service failed: %v\n", err)
-			}
-			return false, 0
-		}
-	}
-}
-
-func runAsService() error {
-	return svc.Run(serviceName, &supervisorService{})
-}
-
-func withServiceManager(fn func(*mgr.Mgr) error) error {
-	m, err := mgr.Connect()
-	if err != nil {
-		return err
-	}
-	defer m.Disconnect()
-	return fn(m)
-}
-
-func installService(exePath, serviceUser, servicePassword string) error {
-	return withServiceManager(func(m *mgr.Mgr) error {
-		s, err := m.OpenService(serviceName)
-		if err == nil {
-			s.Close()
-			return fmt.Errorf("install failed: service %q already exists", serviceName)
-		}
-
-		cfg := mgr.Config{
-			DisplayName:      serviceDisplay,
-			Description:      serviceDesc,
-			StartType:        mgr.StartAutomatic,
-			DelayedAutoStart: true,
-		}
-		if serviceUser != "" {
-			cfg.ServiceStartName = serviceUser
-			cfg.Password = servicePassword
-			if servicePassword == "" {
-				fmt.Printf("Installing service as passwordless identity %q\n", serviceUser)
-			} else {
-				fmt.Printf("Installing service as user %q\n", serviceUser)
-			}
-		} else {
-			fmt.Println("Installing service as LocalSystem (default). Use -service-user to run as a specific user account.")
-		}
-
-		s, err = m.CreateService(serviceName, exePath, cfg)
-		if err != nil {
-			return fmt.Errorf("install failed: create service: %w", err)
-		}
-		defer s.Close()
-
-		fmt.Printf("Service %q installed successfully.\n", serviceName)
-		fmt.Printf("Start it with: %s start\n", filepath.Base(exePath))
-		return nil
-	})
-}
-
-func uninstallService() error {
-	return withServiceManager(func(m *mgr.Mgr) error {
-		s, err := m.OpenService(serviceName)
-		if err != nil {
-			return fmt.Errorf("uninstall failed: service %q not found: %w", serviceName, err)
-		}
-		defer s.Close()
-
-		if err := s.Delete(); err != nil {
-			return fmt.Errorf("uninstall failed: delete service: %w", err)
-		}
-
-		fmt.Printf("Service %q uninstalled.\n", serviceName)
-		return nil
-	})
-}
-
-func startService() error {
-	return withServiceManager(func(m *mgr.Mgr) error {
-		s, err := m.OpenService(serviceName)
-		if err != nil {
-			return fmt.Errorf("start failed: service %q not found: %w", serviceName, err)
-		}
-		defer s.Close()
-
-		if err := s.Start(); err != nil {
-			return fmt.Errorf("start failed: %w", err)
-		}
-
-		fmt.Printf("Service %q started.\n", serviceName)
-		return nil
-	})
-}
-
-func stopService() error {
-	return withServiceManager(func(m *mgr.Mgr) error {
-		s, err := m.OpenService(serviceName)
-		if err != nil {
-			return fmt.Errorf("stop failed: service %q not found: %w", serviceName, err)
-		}
-		defer s.Close()
-
-		if _, err := s.Control(svc.Stop); err != nil {
-			return fmt.Errorf("stop failed: %w", err)
-		}
-
-		fmt.Printf("Service %q stopping.\n", serviceName)
-		return nil
-	})
-}
-
-func serviceStatus() error {
-	return withServiceManager(func(m *mgr.Mgr) error {
-		s, err := m.OpenService(serviceName)
-		if err != nil {
-			return fmt.Errorf("status failed: service %q not found: %w", serviceName, err)
-		}
-		defer s.Close()
-
-		st, err := s.Query()
-		if err != nil {
-			return fmt.Errorf("status failed: query service: %w", err)
-		}
-
-		states := map[svc.State]string{
-			svc.Stopped:         "Stopped",
-			svc.StartPending:    "StartPending",
-			svc.StopPending:     "StopPending",
-			svc.Running:         "Running",
-			svc.ContinuePending: "ContinuePending",
-			svc.PausePending:    "PausePending",
-			svc.Paused:          "Paused",
-		}
-		state, ok := states[st.State]
-		if !ok {
-			state = fmt.Sprintf("Unknown(%d)", st.State)
-		}
-
-		fmt.Printf("Service %q: %s\n", serviceName, state)
-		return nil
-	})
-}
-
-func isWindowsService() (bool, error) {
-	return svc.IsWindowsService()
-}

package/supervisor/update_state.go

@@ -1,264 +0,0 @@
-package main
-
-import (
-	"encoding/json"
-	"errors"
-	"fmt"
-	"os"
-	"path/filepath"
-	"strings"
-	"time"
-)
-
-const (
-	updateScopeMCP        = "mcp"
-	updateScopeSupervisor = "supervisor"
-
-	// A coordinator lock older than this is treated as stale metadata for
-	// diagnostics, but age never overrides live-owner safety.
-	updateCoordinatorLockMaxAge = 10 * time.Minute
-
-	updatePhaseIdle       = "idle"
-	updatePhaseStaged     = "staged"
-	updatePhaseApplying   = "applying"
-	updatePhaseRestarting = "restarting"
-	updatePhaseVerifying  = "verifying"
-	updatePhaseRollback   = "rollback"
-	updatePhaseFailed     = "failed"
-)
-
-type UpdateState struct {
-	Scope           string    `json:"scope"`
-	Phase           string    `json:"phase"`
-	TargetVersion   string    `json:"targetVersion"`
-	PreviousVersion string    `json:"previousVersion"`
-	UpdatedAt       time.Time `json:"updatedAt"`
-	LastError       string    `json:"lastError"`
-}
-
-type UpdateStateStore struct {
-	path string
-	log  *Logger
-}
-
-func NewUpdateStateStore(path string, log *Logger) *UpdateStateStore {
-	return &UpdateStateStore{path: path, log: log}
-}
-
-func (s *UpdateStateStore) Load() (UpdateState, error) {
-	data, err := os.ReadFile(s.path)
-	if err != nil {
-		if errors.Is(err, os.ErrNotExist) {
-			return UpdateState{Phase: updatePhaseIdle, UpdatedAt: time.Now().UTC()}, nil
-		}
-		return UpdateState{}, err
-	}
-
-	var state UpdateState
-	if err := json.Unmarshal(data, &state); err != nil {
-		return UpdateState{}, err
-	}
-	if state.Phase == "" {
-		state.Phase = updatePhaseIdle
-	}
-	return state, nil
-}
-
-func (s *UpdateStateStore) Save(state UpdateState) error {
-	if state.UpdatedAt.IsZero() {
-		state.UpdatedAt = time.Now().UTC()
-	}
-
-	if err := os.MkdirAll(filepath.Dir(s.path), 0755); err != nil {
-		return fmt.Errorf("create update state dir: %w", err)
-	}
-
-	data, err := json.Marshal(state)
-	if err != nil {
-		return fmt.Errorf("marshal update state: %w", err)
-	}
-	if err := atomicWrite(s.path, data); err != nil {
-		return fmt.Errorf("write update state: %w", err)
-	}
-	return nil
-}
-
-func (s *UpdateStateStore) Transition(scope, phase, targetVersion, previousVersion, lastError string) {
-	state := UpdateState{
-		Scope:           scope,
-		Phase:           phase,
-		TargetVersion:   targetVersion,
-		PreviousVersion: previousVersion,
-		UpdatedAt:       time.Now().UTC(),
-		LastError:       lastError,
-	}
-	if err := s.Save(state); err != nil {
-		s.log.Warn("Failed to persist update state (scope=%s phase=%s): %v", scope, phase, err)
-	}
-}
-
-type updateLockOwner struct {
-	Scope     string    `json:"scope"`
-	PID       int       `json:"pid"`
-	UpdatedAt time.Time `json:"updatedAt"`
-}
-
-type UpdateCoordinatorLock struct {
-	path  string
-	scope string
-	log   *Logger
-}
-
-type updateLockFile interface {
-	Write([]byte) (int, error)
-	Close() error
-}
-
-var openUpdateLockFile = func(lockPath string) (updateLockFile, error) {
-	return os.OpenFile(lockPath, os.O_CREATE|os.O_EXCL|os.O_WRONLY, 0644)
-}
-
-func writeUpdateLockMetadata(lockPath string, payload []byte) error {
-	f, err := openUpdateLockFile(lockPath)
-	if err != nil {
-		return err
-	}
-
-	if _, err := f.Write(payload); err != nil {
-		closeErr := f.Close()
-		_ = os.Remove(lockPath)
-		if closeErr != nil {
-			return errors.Join(fmt.Errorf("write lock metadata: %w", err), fmt.Errorf("close lock file after write failure: %w", closeErr))
-		}
-		return fmt.Errorf("write lock metadata: %w", err)
-	}
-
-	if err := f.Close(); err != nil {
-		_ = os.Remove(lockPath)
-		return fmt.Errorf("close lock metadata file: %w", err)
-	}
-
-	return nil
-}
-
-func AcquireUpdateCoordinatorLock(lockPath, scope string, log *Logger) (*UpdateCoordinatorLock, bool) {
-	owner := updateLockOwner{Scope: scope, PID: os.Getpid(), UpdatedAt: time.Now().UTC()}
-	payload, _ := json.Marshal(owner)
-
-	err := writeUpdateLockMetadata(lockPath, payload)
-	if err == nil {
-		log.Debug("Update coordinator lock acquired by %s", scope)
-		return &UpdateCoordinatorLock{path: lockPath, scope: scope, log: log}, true
-	}
-
-	if !errors.Is(err, os.ErrExist) {
-		log.Warn("Failed to acquire update coordinator lock %s: %v", lockPath, err)
-		return nil, false
-	}
-
-	data, readErr := os.ReadFile(lockPath)
-	if readErr != nil {
-		log.Warn("Update coordinator lock exists but could not be read (%s): %v", lockPath, readErr)
-		return nil, false
-	}
-
-	var holder updateLockOwner
-	if json.Unmarshal(data, &holder) == nil {
-		lockAge := time.Since(holder.UpdatedAt)
-		alive := holder.PID > 0 && IsProcessAlive(holder.PID)
-		staleByAge := !holder.UpdatedAt.IsZero() && lockAge > updateCoordinatorLockMaxAge
-
-		if alive {
-			holderScope := holder.Scope
-			if holderScope == "" {
-				holderScope = "unknown"
-			}
-			ageNote := ""
-			if staleByAge {
-				ageNote = fmt.Sprintf("; stale metadata age %v exceeds %v", lockAge.Round(time.Second), updateCoordinatorLockMaxAge)
-			}
-			log.Info("Skipping %s update apply: coordinator lock held by %s (PID %d, age %v%s)", scope, holderScope, holder.PID, lockAge.Round(time.Second), ageNote)
-			return nil, false
-		}
-
-		holderScope := holder.Scope
-		if holderScope == "" {
-			holderScope = "unknown"
-		}
-		reason := "owner PID not alive"
-		if staleByAge {
-			reason = fmt.Sprintf("owner PID not alive (metadata age %v exceeds %v)", lockAge.Round(time.Second), updateCoordinatorLockMaxAge)
-		}
-		log.Warn("Reclaiming update coordinator lock for %s: previous owner=%s pid=%d (%s)", scope, holderScope, holder.PID, reason)
-	}
-
-	_ = os.Remove(lockPath)
-	err = writeUpdateLockMetadata(lockPath, payload)
-	if err != nil {
-		log.Warn("Failed to reclaim update coordinator lock %s: %v", lockPath, err)
-		return nil, false
-	}
-	log.Warn("Reclaimed stale update coordinator lock for %s", scope)
-	return &UpdateCoordinatorLock{path: lockPath, scope: scope, log: log}, true
-}
-
-func (l *UpdateCoordinatorLock) Release() {
-	if l == nil {
-		return
-	}
-	_ = os.Remove(l.path)
-	l.log.Debug("Update coordinator lock released by %s", l.scope)
-}
-
-func recoverPersistedUpdateStateOnStartup(cfg Config, log *Logger) {
-	store := NewUpdateStateStore(cfg.Paths.UpdateState, log)
-	state, err := store.Load()
-	if err != nil {
-		log.Warn("Failed to load persisted update state for startup recovery: %v", err)
-		return
-	}
-
-	scope := state.Scope
-	if scope == "" {
-		scope = updateScopeMCP
-	}
-
-	if scope == updateScopeSupervisor {
-		currentVersion := readTrimmedFile(cfg.Paths.SupervisorVersion)
-		targetVersion := strings.TrimSpace(state.TargetVersion)
-		if targetVersion != "" && currentVersion == targetVersion && state.Phase != updatePhaseIdle {
-			log.Info("Startup recovery: supervisor update %s already applied locally; transitioning state to idle", targetVersion)
-			store.Transition(updateScopeSupervisor, updatePhaseIdle, targetVersion, state.PreviousVersion, "")
-			return
-		}
-	}
-
-	if state.Phase == "" || state.Phase == updatePhaseIdle || state.Phase == updatePhaseFailed {
-		return
-	}
-
-	if !isRecoverableStartupPhase(state.Phase) {
-		return
-	}
-
-	reason := fmt.Sprintf("startup recovery: stale non-idle update state detected (%s/%s)", scope, state.Phase)
-	log.Warn("%s", reason)
-	store.Transition(scope, updatePhaseFailed, state.TargetVersion, state.PreviousVersion, reason)
-}
-
-func isRecoverableStartupPhase(phase string) bool {
-	switch phase {
-	case updatePhaseApplying, updatePhaseRestarting, updatePhaseVerifying, updatePhaseStaged:
-		return true
-	default:
-		return false
-	}
-}
-
-func readTrimmedFile(path string) string {
-	data, err := os.ReadFile(path)
-	if err != nil {
-		return ""
-	}
-	return strings.TrimSpace(string(data))
-}