sensorium-mcp 3.0.1 → 3.0.3

package/supervisor/health.go

@@ -1,6 +1,7 @@
 package main
 
 import (
+	"bytes"
 	"context"
 	"encoding/json"
 	"fmt"
@@ -16,25 +17,27 @@ type MCPClient struct {
 	Secret  string
 	Client  *http.Client
 	Log     *Logger
+	headers map[string]string
 }
 
 func NewMCPClient(port int, secret string) *MCPClient {
+	h := map[string]string{
+		"Content-Type": "application/json",
+		"Accept":       "application/json",
+	}
+	if secret != "" {
+		h["Authorization"] = "Bearer " + secret
+	}
 	return &MCPClient{
 		BaseURL: fmt.Sprintf("http://127.0.0.1:%d", port),
 		Secret:  secret,
 		Client:  &http.Client{Timeout: 10 * time.Second},
+		headers: h,
 	}
 }
 
 func (m *MCPClient) authHeaders() map[string]string {
-	h := map[string]string{
-		"Content-Type": "application/json",
-		"Accept":       "application/json",
-	}
-	if m.Secret != "" {
-		h["Authorization"] = "Bearer " + m.Secret
-	}
-	return h
+	return m.headers
 }
 
 func (m *MCPClient) doReq(ctx context.Context, method, path string, body any) (*http.Response, error) {
@@ -44,7 +47,7 @@ func (m *MCPClient) doReq(ctx context.Context, method, path string, body any) (*
 		if err != nil {
 			return nil, err
 		}
-		bodyReader = strings.NewReader(string(data))
+		bodyReader = bytes.NewReader(data)
 	}
 
 	req, err := http.NewRequestWithContext(ctx, method, m.BaseURL+path, bodyReader)
@@ -96,6 +99,26 @@ func (m *MCPClient) WaitForReady(ctx context.Context, pollInterval, timeout time
 	}
 }
 
+// PrepareShutdown asks the MCP server to write a reconnect snapshot before being killed.
+// Best-effort: returns false on any error so the caller can proceed with the kill.
+func (m *MCPClient) PrepareShutdown(ctx context.Context) bool {
+	ctx2, cancel := context.WithTimeout(ctx, 3*time.Second)
+	defer cancel()
+	resp, err := m.doReq(ctx2, "POST", "/api/prepare-shutdown", nil)
+	if err != nil {
+		if m.Log != nil {
+			m.Log.Debug("PrepareShutdown: POST /api/prepare-shutdown failed: %v", err)
+		}
+		return false
+	}
+	defer resp.Body.Close()
+	ok := resp.StatusCode == 200
+	if m.Log != nil {
+		m.Log.Info("PrepareShutdown: POST /api/prepare-shutdown => %d", resp.StatusCode)
+	}
+	return ok
+}
+
 // GetRootThreads fetches the list of root threads from the server.
 func (m *MCPClient) GetRootThreads(ctx context.Context) ([]map[string]any, error) {
 	return m.fetchThreadList(ctx, "/api/threads/roots")
@@ -292,7 +315,7 @@ func (m *MCPClient) OpenMCPSession(ctx context.Context) (string, error) {
 	if err != nil {
 		return sessionID, nil // session created, notification failed — non-fatal
 	}
-	notifReq.Body = io.NopCloser(strings.NewReader(string(data)))
+	notifReq.Body = io.NopCloser(bytes.NewReader(data))
 	for k, v := range m.authHeaders() {
 		notifReq.Header.Set(k, v)
 	}
@@ -357,8 +380,11 @@ func (m *MCPClient) CallStartThread(ctx context.Context, sessionID string, threa
 	if err != nil {
 		return "", err
 	}
-	data, _ := json.Marshal(payload)
-	req.Body = io.NopCloser(strings.NewReader(string(data)))
+	data, err := json.Marshal(payload)
+	if err != nil {
+		return "", err
+	}
+	req.Body = io.NopCloser(bytes.NewReader(data))
 	for k, v := range m.authHeaders() {
 		req.Header.Set(k, v)
 	}

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

@@ -166,10 +166,16 @@ func runSupervisor(runningAsService bool) error {
 	mcp := NewMCPClient(cfg.MCPHttpPort, cfg.MCPHttpSecret)
 	mcp.Log = log
 
-	// Clean stale PID files from previous runs
-	CleanStalePIDs(cfg.Paths.PIDsDir, log)
-
-	// Kill orphan process on our port
+	// Kill orphan thread processes from previous runs, then clean PID files
+	KillOrphanThreads(cfg.Paths.PIDsDir, log)
+
+	// Kill orphan MCP server from previous run
+	if oldPid, err := ReadPIDFile(cfg.Paths.ServerPID); err == nil && oldPid > 0 && IsProcessAlive(oldPid) {
+		log.Info("Killing orphan MCP server (PID %d) from previous run", oldPid)
+		_ = KillProcess(oldPid, log)
+		time.Sleep(1 * time.Second) // allow port to release
+	}
+	_ = os.Remove(cfg.Paths.ServerPID)
 	KillByPort(cfg.MCPHttpPort, log)
 
 	// Spawn MCP server
@@ -369,6 +375,9 @@ func runSupervisor(runningAsService bool) error {
 	<-keeperPollerDone
 	<-healthDone
 
+	// Ask MCP to write reconnect snapshot before killing it
+	mcp.PrepareShutdown(context.Background())
+
 	// Kill server process
 	pid, err := ReadPIDFile(cfg.Paths.ServerPID)
 	if err == nil && pid > 0 {

package/supervisor/process.go

@@ -242,6 +242,35 @@ func ListThreadPIDs(pidsDir string) map[string]int {
 	return result
 }
 
+// KillOrphanThreads kills any alive processes listed in PID files (leftovers from
+// a previous supervisor run) and then removes the PID files. Called on startup
+// before the MCP server is launched, so all thread PIDs are guaranteed to be stale.
+func KillOrphanThreads(pidsDir string, log *Logger) {
+	pids := ListThreadPIDs(pidsDir)
+	if len(pids) == 0 {
+		log.Debug("KillOrphanThreads: no PID files found")
+		return
+	}
+	log.Info("KillOrphanThreads: checking %d PID files for orphan processes", len(pids))
+	killed := 0
+	for threadID, pid := range pids {
+		path := filepath.Join(pidsDir, threadID+".pid")
+		if IsProcessAlive(pid) {
+			log.Info("Killing orphan thread %s (PID %d)", threadID, pid)
+			if err := KillProcess(pid, log); err != nil {
+				log.Warn("Failed to kill orphan PID %d: %v", pid, err)
+			}
+			killed++
+		}
+		_ = os.Remove(path)
+	}
+	if killed > 0 {
+		log.Info("KillOrphanThreads: killed %d orphan processes, cleaned %d PID files", killed, len(pids))
+	} else {
+		log.Info("KillOrphanThreads: no orphans found, cleaned %d stale PID files", len(pids))
+	}
+}
+
 // CleanStalePIDs removes PID files for processes that are no longer running.
 func CleanStalePIDs(pidsDir string, log *Logger) {
 	pids := ListThreadPIDs(pidsDir)

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

@@ -433,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)
@@ -499,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
 	}
@@ -514,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
 }
 
@@ -548,7 +543,7 @@ func requestSupervisorRestart(log *Logger) error {
 	}
 
 	go func() {
-		time.Sleep(250 * time.Millisecond)
+		time.Sleep(2 * time.Second)
 		os.Exit(0)
 	}()
 
@@ -557,6 +552,12 @@ func requestSupervisorRestart(log *Logger) error {
 
 func (u *Updater) killServer() {
 	u.log.Info("Updater: stopping current MCP server for update")
+
+	// Ask the MCP server to write a reconnect snapshot before we kill it.
+	// On Windows, taskkill /F doesn't allow graceful shutdown, so this is
+	// the only way the snapshot gets written.
+	u.mcp.PrepareShutdown(context.Background())
+
 	pid, err := ReadPIDFile(u.cfg.Paths.ServerPID)
 	if err != nil {
 		u.log.Warn("Could not read server PID file: %v", err)
@@ -600,7 +601,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 {