sensorium-mcp 3.0.0 → 3.0.2

package/supervisor/keeper.go

@@ -114,6 +114,7 @@ func (k *Keeper) run(ctx context.Context) {
 				k.log.Warn("Thread %d (worker %d) is stuck (no heartbeat for %v) — restarting", k.cfg.ThreadID, activeThreadID, k.global.StuckThreshold)
 				// Kill via MCP API, then fall through to restart
 				k.killThread(ctx, activeThreadID)
+				retryCount = 0
 				activeThreadID = k.cfg.ThreadID // reset — will get new worker ID on restart
 			} else {
 				// Healthy — reset counters
@@ -129,7 +130,31 @@ func (k *Keeper) run(ctx context.Context) {
 			}
 		}
 
-		// Thread is not running (or was stuck and killed)
+		// Thread is not running (or was stuck and killed).
+		// Detect fast-exit: if the previous successful start was recent, the thread exited too quickly.
+		if !lastStartTime.IsZero() && time.Since(lastStartTime) < k.global.FastExitThreshold {
+			fastExitCount++
+			if fastExitCount >= k.global.FastExitMaxCount {
+				cooldown := time.Duration(float64(k.global.FastExitBaseCooldown) * math.Pow(2, float64(fastExitEscalation)))
+				if cooldown > k.global.FastExitMaxCooldown {
+					cooldown = k.global.FastExitMaxCooldown
+				}
+				k.log.Warn("Thread %d: %d consecutive fast exits — backing off %v", k.cfg.ThreadID, fastExitCount, cooldown)
+				if k.onDeath != nil {
+					k.onDeath(k.cfg.ThreadID, k.cfg.SessionName+" (repeated fast exits — check credits/API key)")
+				}
+				fastExitEscalation++
+				k.sleep(ctx, cooldown)
+				fastExitCount = 0
+				retryCount = 0
+				return
+			}
+		} else if !lastStartTime.IsZero() {
+			// Previous start was long ago — not a fast exit pattern, reset counters
+			fastExitCount = 0
+			fastExitEscalation = 0
+		}
+
 		if retryCount >= k.cfg.MaxRetries {
 			cooldown := k.global.KeeperCooldown
 			if k.cfg.CooldownMs > 0 {
@@ -157,10 +182,10 @@ func (k *Keeper) run(ctx context.Context) {
 			return
 		}
 
-		lastStartTime = time.Now()
 		ok, workerID := k.callStartThread(ctx)
 
 		if ok {
+			lastStartTime = time.Now()
 			if workerID > 0 {
 				activeThreadID = workerID
 				k.log.Info("Thread %d start_thread succeeded (worker %d)", k.cfg.ThreadID, workerID)
@@ -168,31 +193,7 @@ func (k *Keeper) run(ctx context.Context) {
 				k.log.Info("Thread %d start_thread succeeded", k.cfg.ThreadID)
 			}
 			retryCount = 0
-			// Check for fast exit on next check
 		} else {
-			// Check for fast exit pattern
-			if !lastStartTime.IsZero() && time.Since(lastStartTime) < k.global.FastExitThreshold {
-				fastExitCount++
-				if fastExitCount >= k.global.FastExitMaxCount {
-					cooldown := time.Duration(float64(k.global.FastExitBaseCooldown) * math.Pow(2, float64(fastExitEscalation)))
-					if cooldown > k.global.FastExitMaxCooldown {
-						cooldown = k.global.FastExitMaxCooldown
-					}
-					k.log.Warn("Thread %d: %d consecutive fast exits — backing off %v", k.cfg.ThreadID, fastExitCount, cooldown)
-					if k.onDeath != nil {
-						k.onDeath(k.cfg.ThreadID, k.cfg.SessionName+" (repeated fast exits — check credits/API key)")
-					}
-					fastExitEscalation++
-					k.sleep(ctx, cooldown)
-					fastExitCount = 0
-					retryCount = 0
-					return
-				}
-			} else {
-				fastExitCount = 0
-				fastExitEscalation = 0
-			}
-
 			retryCount++
 			delay := k.backoff(retryCount)
 			k.log.Info("Backing off %v before next attempt", delay)

package/supervisor/lock.go

@@ -47,6 +47,7 @@ func AcquireLock(lockPath string, log *Logger) bool {
 	}
 	fmt.Fprintf(f, "%d", os.Getpid())
 	f.Close()
+	log.Info("Lock acquired: %s (PID %d)", lockPath, os.Getpid())
 	return true
 }
 

package/supervisor/main.go

@@ -395,10 +395,6 @@ func fetchKeeperSettings(ctx context.Context, mcp *MCPClient, log *Logger) ([]Ke
 			continue
 		}
 
-		if typ, _ := r["type"].(string); typ == "worker" {
-			continue
-		}
-
 		// Skip non-active roots (archived, expired, exited)
 		if status, _ := r["status"].(string); status != "" && status != "active" {
 			continue

package/supervisor/service_windows.go

@@ -5,6 +5,7 @@ package main
 import (
 	"fmt"
 	"os"
+	"path/filepath"
 	"time"
 
 	"golang.org/x/sys/windows/svc"
@@ -58,159 +59,136 @@ func runAsService() error {
 	return svc.Run(serviceName, &supervisorService{})
 }
 
-func installService(exePath, serviceUser, servicePassword string) error {
+func withServiceManager(fn func(*mgr.Mgr) error) error {
 	m, err := mgr.Connect()
 	if err != nil {
-		return fmt.Errorf("install failed: connect to service manager: %w", err)
+		return err
 	}
 	defer m.Disconnect()
+	return fn(m)
+}
 
-	s, err := m.OpenService(serviceName)
-	if err == nil {
-		s.Close()
-		return fmt.Errorf("install failed: service %q already exists", serviceName)
-	}
+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)
+		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.Printf("Installing service as user %q\n", serviceUser)
+			fmt.Println("Installing service as LocalSystem (default). Use -service-user to run as a specific user account.")
 		}
-	} 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()
+		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", filepathBase(exePath))
-	return nil
+		fmt.Printf("Service %q installed successfully.\n", serviceName)
+		fmt.Printf("Start it with: %s start\n", filepath.Base(exePath))
+		return nil
+	})
 }
 
 func uninstallService() error {
-	m, err := mgr.Connect()
-	if err != nil {
-		return fmt.Errorf("uninstall failed: connect to service manager: %w", err)
-	}
-	defer m.Disconnect()
-
-	s, err := m.OpenService(serviceName)
-	if err != nil {
-		return fmt.Errorf("uninstall failed: service %q not found: %w", serviceName, err)
-	}
-	defer s.Close()
+	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)
-	}
+		if err := s.Delete(); err != nil {
+			return fmt.Errorf("uninstall failed: delete service: %w", err)
+		}
 
-	fmt.Printf("Service %q uninstalled.\n", serviceName)
-	return nil
+		fmt.Printf("Service %q uninstalled.\n", serviceName)
+		return nil
+	})
 }
 
 func startService() error {
-	m, err := mgr.Connect()
-	if err != nil {
-		return fmt.Errorf("start failed: connect to service manager: %w", err)
-	}
-	defer m.Disconnect()
-
-	s, err := m.OpenService(serviceName)
-	if err != nil {
-		return fmt.Errorf("start failed: service %q not found: %w", serviceName, err)
-	}
-	defer s.Close()
+	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)
-	}
+		if err := s.Start(); err != nil {
+			return fmt.Errorf("start failed: %w", err)
+		}
 
-	fmt.Printf("Service %q started.\n", serviceName)
-	return nil
+		fmt.Printf("Service %q started.\n", serviceName)
+		return nil
+	})
 }
 
 func stopService() error {
-	m, err := mgr.Connect()
-	if err != nil {
-		return fmt.Errorf("stop failed: connect to service manager: %w", err)
-	}
-	defer m.Disconnect()
-
-	s, err := m.OpenService(serviceName)
-	if err != nil {
-		return fmt.Errorf("stop failed: service %q not found: %w", serviceName, err)
-	}
-	defer s.Close()
+	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)
-	}
+		if _, err := s.Control(svc.Stop); err != nil {
+			return fmt.Errorf("stop failed: %w", err)
+		}
 
-	fmt.Printf("Service %q stopping.\n", serviceName)
-	return nil
+		fmt.Printf("Service %q stopping.\n", serviceName)
+		return nil
+	})
 }
 
 func serviceStatus() error {
-	m, err := mgr.Connect()
-	if err != nil {
-		return fmt.Errorf("status failed: connect to service manager: %w", err)
-	}
-	defer m.Disconnect()
-
-	s, err := m.OpenService(serviceName)
-	if err != nil {
-		return fmt.Errorf("status failed: service %q not found: %w", serviceName, err)
-	}
-	defer s.Close()
+	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)
-	}
+		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)
-	}
+		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
+		fmt.Printf("Service %q: %s\n", serviceName, state)
+		return nil
+	})
 }
 
 func isWindowsService() (bool, error) {
 	return svc.IsWindowsService()
 }
-
-func filepathBase(path string) string {
-	if path == "" {
-		return serviceName
-	}
-	for i := len(path) - 1; i >= 0; i-- {
-		if path[i] == '\\' || path[i] == '/' {
-			return path[i+1:]
-		}
-	}
-	return path
-}

package/supervisor/updater.go

@@ -7,6 +7,7 @@ import (
 	"io"
 	"net/http"
 	"os"
+	"os/exec"
 	"path/filepath"
 	"runtime"
 	"strings"
@@ -432,6 +433,9 @@ func (u *Updater) checkSupervisorUpdate(ctx context.Context) {
 	u.state.Transition(updateScopeSupervisor, updatePhaseStaged, remote, local, "")
 	notifyUpdaterOperator(u.cfg, u.log, fmt.Sprintf("⚙️ Supervisor: downloaded %s. Restarting supervisor to apply update...", remote), 0)
 
+	// Reset start time so minimum uptime is re-enforced after restart
+	u.startAt = time.Now()
+
 	isService, err := isWindowsService()
 	if err != nil {
 		markFailed(err)
@@ -450,7 +454,7 @@ func (u *Updater) checkSupervisorUpdate(ctx context.Context) {
 		return
 	}
 
-	if err := signalSelf(syscall.SIGTERM); err != nil {
+	if err := requestSupervisorRestart(u.log); err != nil {
 		markFailed(err)
 		u.log.Error("Failed to signal supervisor for restart: %v", err)
 		notifyUpdaterOperator(u.cfg, u.log, "🔴 Supervisor: update downloaded but restart signal failed.", 0)
@@ -498,14 +502,6 @@ func (u *Updater) downloadSupervisorBinary(ctx context.Context, downloadURL stri
 		return fmt.Errorf("downloaded empty binary")
 	}
 
-	info, err := os.Stat(tmpPath)
-	if err != nil {
-		return err
-	}
-	if info.Size() <= 0 {
-		return fmt.Errorf("downloaded binary has invalid size %d", info.Size())
-	}
-
 	if err := os.Remove(u.cfg.Paths.PendingBinary); err != nil && !os.IsNotExist(err) {
 		return err
 	}
@@ -513,7 +509,7 @@ func (u *Updater) downloadSupervisorBinary(ctx context.Context, downloadURL stri
 		return err
 	}
 
-	u.log.Info("Supervisor binary downloaded to %s (%d bytes)", u.cfg.Paths.PendingBinary, info.Size())
+	u.log.Info("Supervisor binary downloaded to %s (%d bytes)", u.cfg.Paths.PendingBinary, written)
 	return nil
 }
 
@@ -525,6 +521,35 @@ func signalSelf(sig os.Signal) error {
 	return proc.Signal(sig)
 }
 
+func requestSupervisorRestart(log *Logger) error {
+	if runtime.GOOS != "windows" {
+		return signalSelf(syscall.SIGTERM)
+	}
+
+	exePath, err := os.Executable()
+	if err != nil {
+		return fmt.Errorf("resolve executable path: %w", err)
+	}
+
+	cmd := exec.Command(exePath)
+	cmd.Env = os.Environ()
+	setSysProcAttr(cmd)
+	if err := cmd.Start(); err != nil {
+		return fmt.Errorf("start replacement supervisor: %w", err)
+	}
+
+	if log != nil {
+		log.Info("Spawned replacement supervisor process PID %d", cmd.Process.Pid)
+	}
+
+	go func() {
+		time.Sleep(2 * time.Second)
+		os.Exit(0)
+	}()
+
+	return nil
+}
+
 func (u *Updater) killServer() {
 	u.log.Info("Updater: stopping current MCP server for update")
 	pid, err := ReadPIDFile(u.cfg.Paths.ServerPID)
@@ -570,7 +595,7 @@ func (u *Updater) clearNpxCache() {
 		}
 		pkgDir := filepath.Join(base, e.Name(), "node_modules", "sensorium-mcp")
 		// Validate path doesn't escape base directory
-		if !strings.HasPrefix(pkgDir, base) {
+		if !strings.HasPrefix(pkgDir, base+string(os.PathSeparator)) {
 			continue
 		}
 		if _, err := os.Stat(pkgDir); err == nil {