sensorium-mcp 2.17.28 → 3.0.1

package/supervisor/updater.go

@@ -4,21 +4,32 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
+	"io"
 	"net/http"
 	"os"
+	"os/exec"
 	"path/filepath"
 	"runtime"
 	"strings"
+	"syscall"
 	"time"
 )
 
 const registryURL = "https://registry.npmjs.org/sensorium-mcp/latest"
+const supervisorReleaseURL = "https://api.github.com/repos/andriyshevchenko/remote-copilot-mcp/releases/tags/supervisor-latest"
+
+var (
+	notifyUpdaterOperator      = NotifyOperator
+	mcpUpdateReadyPollInterval = 3 * time.Second
+	mcpUpdateReadyTimeout      = 60 * time.Second
+)
 
 // Updater checks the npm registry for new versions and performs updates.
 type Updater struct {
 	cfg     Config
 	mcp     *MCPClient
 	log     *Logger
+	state   *UpdateStateStore
 	startAt time.Time
 	cancel  context.CancelFunc
 	done    chan struct{}
@@ -29,6 +40,7 @@ func NewUpdater(cfg Config, mcp *MCPClient, log *Logger) *Updater {
 		cfg:     cfg,
 		mcp:     mcp,
 		log:     log,
+		state:   NewUpdateStateStore(cfg.Paths.UpdateState, log),
 		startAt: time.Now(),
 		done:    make(chan struct{}),
 	}
@@ -75,6 +87,10 @@ func (u *Updater) run(ctx context.Context) {
 		}
 
 		u.checkAndUpdate(ctx)
+		if ctx.Err() != nil {
+			return
+		}
+		u.checkSupervisorUpdate(ctx)
 	}
 }
 
@@ -159,30 +175,54 @@ func (u *Updater) checkAndUpdate(ctx context.Context) {
 	}
 
 	u.log.Info("Update available: %s → %s", local, remote)
-	NotifyOperator(u.cfg, u.log, fmt.Sprintf("⚙️ Supervisor: updating sensorium v%s → v%s. Grace period %v...", local, remote, u.cfg.GracePeriod), 0)
+	coordLock, ok := AcquireUpdateCoordinatorLock(u.cfg.Paths.UpdateApplyLock, updateScopeMCP, u.log)
+	if !ok {
+		u.log.Info("Deferring MCP update %s → %s due to active update apply lock", local, remote)
+		return
+	}
+	defer coordLock.Release()
+
+	u.state.Transition(updateScopeMCP, updatePhaseApplying, remote, local, "")
+	markFailed := func(err error) {
+		u.state.Transition(updateScopeMCP, updatePhaseFailed, remote, local, err.Error())
+	}
+
+	notifyUpdaterOperator(u.cfg, u.log, fmt.Sprintf("⚙️ Supervisor: updating sensorium v%s → v%s. Grace period %v...", local, remote, u.cfg.GracePeriod), 0)
 
 	// Grace period
 	u.log.Info("Grace period %v...", u.cfg.GracePeriod)
 	select {
 	case <-ctx.Done():
+		markFailed(ctx.Err())
 		return
 	case <-time.After(u.cfg.GracePeriod):
 	}
 
-	// Set maintenance flag — always clean up on exit
-	if err := atomicWrite(u.cfg.Paths.MaintenanceFlag, []byte(time.Now().Format(time.RFC3339))); err != nil {
+	// Set maintenance flag — always clean up on exit.
+	// Written as JSON so TypeScript's checkMaintenanceFlag() can parse the
+	// version and timestamp fields for accurate maintenance notifications.
+	maintenanceJSON, err := json.Marshal(map[string]string{
+		"version":   remote,
+		"timestamp": time.Now().Format(time.RFC3339),
+	})
+	if err != nil {
+		u.log.Warn("Failed to marshal maintenance flag: %v", err)
+	} else if err := atomicWrite(u.cfg.Paths.MaintenanceFlag, maintenanceJSON); err != nil {
 		u.log.Warn("Failed to write maintenance flag: %v", err)
 	}
 	defer os.Remove(u.cfg.Paths.MaintenanceFlag)
 
 	// Kill the current MCP server
 	if ctx.Err() != nil {
+		markFailed(ctx.Err())
 		return
 	}
+	u.state.Transition(updateScopeMCP, updatePhaseRestarting, remote, local, "")
 	u.killServer()
 
 	// Clean npx cache
 	if ctx.Err() != nil {
+		markFailed(ctx.Err())
 		return
 	}
 	u.clearNpxCache()
@@ -191,6 +231,7 @@ func (u *Updater) checkAndUpdate(ctx context.Context) {
 	var pid int
 	for attempt := 1; attempt <= 3; attempt++ {
 		if ctx.Err() != nil {
+			markFailed(ctx.Err())
 			return
 		}
 		pid, err = SpawnMCPServer(u.cfg, u.log)
@@ -204,26 +245,316 @@ func (u *Updater) checkAndUpdate(ctx context.Context) {
 	}
 	if err != nil {
 		u.log.Error("All spawn attempts failed — server is down!")
-		NotifyOperator(u.cfg, u.log, "🔴 Supervisor: update FAILED — server is down! Manual intervention required.", 0)
+		markFailed(err)
+		notifyUpdaterOperator(u.cfg, u.log, "🔴 Supervisor: update FAILED — server is down! Manual intervention required.", 0)
 		return
 	}
 
-	// Wait for new server to be ready
-	if u.mcp.WaitForReady(ctx, 3*time.Second, 60*time.Second) {
-		u.log.Info("Updated MCP server ready (PID %d)", pid)
-	} else {
-		u.log.Warn("Updated server did not become ready in 60s")
+	if !u.verifyUpdatedMCPServerReady(ctx, remote, local, pid) {
+		return
 	}
 
 	u.setLocalVersion(remote)
+	u.state.Transition(updateScopeMCP, updatePhaseIdle, remote, local, "")
 
-	NotifyOperator(u.cfg, u.log, fmt.Sprintf("✅ Supervisor: update to v%s complete. Server ready.", remote), 0)
+	notifyUpdaterOperator(u.cfg, u.log, fmt.Sprintf("✅ Supervisor: update to v%s complete. Server ready.", remote), 0)
 	u.log.Info("Update complete: v%s → v%s", local, remote)
 
 	// Reset start time for min uptime tracking
 	u.startAt = time.Now()
 }
 
+func (u *Updater) verifyUpdatedMCPServerReady(ctx context.Context, remote, local string, pid int) bool {
+	u.state.Transition(updateScopeMCP, updatePhaseVerifying, remote, local, "")
+	if u.mcp.WaitForReady(ctx, mcpUpdateReadyPollInterval, mcpUpdateReadyTimeout) {
+		u.log.Info("Updated MCP server ready (PID %d)", pid)
+		return true
+	}
+
+	errMsg := fmt.Sprintf("updated MCP server did not become ready within %v after restart (pid=%d)", mcpUpdateReadyTimeout, pid)
+	u.log.Error(errMsg)
+	u.state.Transition(updateScopeMCP, updatePhaseFailed, remote, local, errMsg)
+	notifyUpdaterOperator(u.cfg, u.log, fmt.Sprintf("🔴 Supervisor: update to v%s FAILED verification. Server did not become ready after restart.", remote), 0)
+	return false
+}
+
+type githubRelease struct {
+	TagName string `json:"tag_name"`
+	Name    string `json:"name"`
+	Assets  []struct {
+		Name string `json:"name"`
+		URL  string `json:"browser_download_url"`
+		Size int64  `json:"size"`
+	} `json:"assets"`
+}
+
+func (u *Updater) getSupervisorRelease(ctx context.Context) (string, string, error) {
+	ctx2, cancel := context.WithTimeout(ctx, 20*time.Second)
+	defer cancel()
+
+	req, err := http.NewRequestWithContext(ctx2, http.MethodGet, supervisorReleaseURL, nil)
+	if err != nil {
+		return "", "", err
+	}
+	req.Header.Set("Accept", "application/vnd.github+json")
+	req.Header.Set("User-Agent", "sensorium-supervisor-updater")
+
+	resp, err := http.DefaultClient.Do(req)
+	if err != nil {
+		return "", "", err
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		return "", "", fmt.Errorf("GitHub releases HTTP %d", resp.StatusCode)
+	}
+
+	var release githubRelease
+	if err := json.NewDecoder(resp.Body).Decode(&release); err != nil {
+		return "", "", err
+	}
+
+	assetName := supervisorAssetName()
+	for _, asset := range release.Assets {
+		if asset.Name != assetName {
+			continue
+		}
+
+		version := strings.TrimSpace(release.Name)
+		if version == "" {
+			version = strings.TrimSpace(release.TagName)
+		}
+		if version == "" {
+			return "", "", fmt.Errorf("release version missing for %s", assetName)
+		}
+		if strings.TrimSpace(asset.URL) == "" {
+			return "", "", fmt.Errorf("release asset URL missing for %s", assetName)
+		}
+
+		return version, asset.URL, nil
+	}
+
+	return "", "", fmt.Errorf("release asset %q not found", assetName)
+}
+
+func supervisorAssetName() string {
+	suffix := ""
+	if runtime.GOOS == "windows" {
+		suffix = ".exe"
+	}
+	return fmt.Sprintf("sensorium-supervisor-%s-%s%s", runtime.GOOS, runtime.GOARCH, suffix)
+}
+
+func (u *Updater) getLocalSupervisorVersion() string {
+	data, err := os.ReadFile(u.cfg.Paths.SupervisorVersion)
+	if err != nil {
+		return ""
+	}
+	return strings.TrimSpace(string(data))
+}
+
+func (u *Updater) setLocalSupervisorVersion(v string) {
+	os.MkdirAll(u.cfg.DataDir, 0755)
+	if err := atomicWrite(u.cfg.Paths.SupervisorVersion, []byte(v)); err != nil {
+		u.log.Warn("Failed to write supervisor version file: %v", err)
+	}
+}
+
+func (u *Updater) stagePendingSupervisorVersion(v string) error {
+	if err := os.MkdirAll(filepath.Dir(u.cfg.Paths.PendingVersion), 0755); err != nil {
+		return fmt.Errorf("create pending supervisor version dir: %w", err)
+	}
+	if err := atomicWrite(u.cfg.Paths.PendingVersion, []byte(v)); err != nil {
+		return fmt.Errorf("write pending supervisor version: %w", err)
+	}
+	return nil
+}
+
+func (u *Updater) checkSupervisorUpdate(ctx context.Context) {
+	uptime := time.Since(u.startAt)
+	if uptime < u.cfg.MinUptime {
+		u.log.Info("Deferring supervisor update — too early (uptime %v < %v)", uptime.Round(time.Second), u.cfg.MinUptime)
+		return
+	}
+
+	remote, downloadURL, err := u.getSupervisorRelease(ctx)
+	if err != nil {
+		u.log.Warn("Failed to check supervisor release: %v", err)
+		return
+	}
+
+	local := u.getLocalSupervisorVersion()
+	if local == "" {
+		u.log.Info("No local supervisor version recorded — storing %s", remote)
+		u.setLocalSupervisorVersion(remote)
+		return
+	}
+
+	if local == remote {
+		u.log.Debug("Supervisor updater: version %s is up to date", local)
+		return
+	}
+
+	u.log.Info("Supervisor update available: %s → %s", local, remote)
+	coordLock, ok := AcquireUpdateCoordinatorLock(u.cfg.Paths.UpdateApplyLock, updateScopeSupervisor, u.log)
+	if !ok {
+		u.log.Info("Deferring supervisor binary update %s → %s due to active update apply lock", local, remote)
+		return
+	}
+	defer coordLock.Release()
+
+	markFailed := func(err error) {
+		u.state.Transition(updateScopeSupervisor, updatePhaseFailed, remote, local, err.Error())
+	}
+
+	notifyUpdaterOperator(u.cfg, u.log, fmt.Sprintf("⚙️ Supervisor: updating binary %s → %s. Grace period %v...", local, remote, u.cfg.GracePeriod), 0)
+
+	select {
+	case <-ctx.Done():
+		markFailed(ctx.Err())
+		return
+	case <-time.After(u.cfg.GracePeriod):
+	}
+
+	if err := u.downloadSupervisorBinary(ctx, downloadURL); err != nil {
+		markFailed(err)
+		u.log.Error("Supervisor binary download failed: %v", err)
+		notifyUpdaterOperator(u.cfg, u.log, fmt.Sprintf("🔴 Supervisor: binary update to %s failed during download.", remote), 0)
+		return
+	}
+
+	if err := u.stagePendingSupervisorVersion(remote); err != nil {
+		_ = os.Remove(u.cfg.Paths.PendingBinary)
+		markFailed(err)
+		u.log.Error("Failed to stage supervisor version %s: %v", remote, err)
+		notifyUpdaterOperator(u.cfg, u.log, fmt.Sprintf("🔴 Supervisor: binary update to %s failed during staging.", remote), 0)
+		return
+	}
+	u.state.Transition(updateScopeSupervisor, updatePhaseStaged, remote, local, "")
+	notifyUpdaterOperator(u.cfg, u.log, fmt.Sprintf("⚙️ Supervisor: downloaded %s. Restarting supervisor to apply update...", remote), 0)
+
+	isService, err := isWindowsService()
+	if err != nil {
+		markFailed(err)
+		u.log.Error("Failed to detect service mode for restart: %v", err)
+		notifyUpdaterOperator(u.cfg, u.log, "🔴 Supervisor: update downloaded but service detection failed.", 0)
+		return
+	}
+	u.state.Transition(updateScopeSupervisor, updatePhaseRestarting, remote, local, "")
+
+	if isService {
+		if err := scheduleServiceRestartForUpdate(u.log); err != nil {
+			markFailed(err)
+			u.log.Error("Failed to schedule service restart: %v", err)
+			notifyUpdaterOperator(u.cfg, u.log, "🔴 Supervisor: update downloaded but service restart scheduling failed.", 0)
+		}
+		return
+	}
+
+	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)
+	}
+}
+
+func (u *Updater) downloadSupervisorBinary(ctx context.Context, downloadURL string) error {
+	if err := os.MkdirAll(u.cfg.Paths.BinaryDir, 0755); err != nil {
+		return fmt.Errorf("create binary dir: %w", err)
+	}
+
+	tmpPath := u.cfg.Paths.PendingBinary + ".download"
+	defer os.Remove(tmpPath)
+
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, downloadURL, nil)
+	if err != nil {
+		return err
+	}
+	req.Header.Set("User-Agent", "sensorium-supervisor-updater")
+
+	resp, err := http.DefaultClient.Do(req)
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		return fmt.Errorf("download HTTP %d", resp.StatusCode)
+	}
+
+	f, err := os.OpenFile(tmpPath, os.O_CREATE|os.O_TRUNC|os.O_WRONLY, 0755)
+	if err != nil {
+		return err
+	}
+
+	written, copyErr := io.Copy(f, resp.Body)
+	closeErr := f.Close()
+	if copyErr != nil {
+		return copyErr
+	}
+	if closeErr != nil {
+		return closeErr
+	}
+	if written <= 0 {
+		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
+	}
+	if err := os.Rename(tmpPath, u.cfg.Paths.PendingBinary); err != nil {
+		return err
+	}
+
+	u.log.Info("Supervisor binary downloaded to %s (%d bytes)", u.cfg.Paths.PendingBinary, info.Size())
+	return nil
+}
+
+func signalSelf(sig os.Signal) error {
+	proc, err := os.FindProcess(os.Getpid())
+	if err != nil {
+		return err
+	}
+	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(250 * time.Millisecond)
+		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)

package/supervisor/updater_test.go

@@ -0,0 +1,64 @@
+package main
+
+import (
+	"context"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+)
+
+func TestVerifyUpdatedMCPServerReady_FailureSetsFailedStateAndNoSuccessMessage(t *testing.T) {
+	dir := t.TempDir()
+	log := NewLogger(filepath.Join(dir, "test.log"))
+	defer log.Close()
+
+	cfg := Config{
+		DataDir: dir,
+		Paths: Paths{
+			UpdateState: filepath.Join(dir, "update-state.json"),
+		},
+	}
+
+	u := NewUpdater(cfg, NewMCPClient(1, ""), log)
+	u.state = NewUpdateStateStore(cfg.Paths.UpdateState, log)
+
+	origNotify := notifyUpdaterOperator
+	origPoll := mcpUpdateReadyPollInterval
+	origTimeout := mcpUpdateReadyTimeout
+	defer func() {
+		notifyUpdaterOperator = origNotify
+		mcpUpdateReadyPollInterval = origPoll
+		mcpUpdateReadyTimeout = origTimeout
+	}()
+
+	mcpUpdateReadyPollInterval = 1 * time.Millisecond
+	mcpUpdateReadyTimeout = 5 * time.Millisecond
+
+	var messages []string
+	notifyUpdaterOperator = func(_ Config, _ *Logger, text string, _ int) {
+		messages = append(messages, text)
+	}
+
+	ok := u.verifyUpdatedMCPServerReady(context.Background(), "2.0.0", "1.0.0", 4242)
+	if ok {
+		t.Fatal("expected verification to fail")
+	}
+
+	state, err := u.state.Load()
+	if err != nil {
+		t.Fatalf("load update state: %v", err)
+	}
+	if state.Phase != updatePhaseFailed {
+		t.Fatalf("state phase = %q, want %q", state.Phase, updatePhaseFailed)
+	}
+	if !strings.Contains(state.LastError, "did not become ready") {
+		t.Fatalf("last error = %q, want readiness failure detail", state.LastError)
+	}
+	if len(messages) == 0 {
+		t.Fatal("expected failure notification message")
+	}
+	if strings.Contains(messages[len(messages)-1], "complete") {
+		t.Fatalf("unexpected success message: %q", messages[len(messages)-1])
+	}
+}

package/scripts/install-supervisor.ps1

@@ -1,67 +0,0 @@
-#!/usr/bin/env pwsh
-<#
-.SYNOPSIS
-    Build and install the sensorium-supervisor Go binary.
-.DESCRIPTION
-    Compiles the Go supervisor and places it in ~/.remote-copilot-mcp/bin/.
-    Requires Go 1.22+ installed and on PATH.
-.PARAMETER Force
-    Rebuild even if the binary already exists.
-#>
-param(
-    [switch]$Force
-)
-
-$ErrorActionPreference = "Stop"
-
-$DataDir = Join-Path $env:USERPROFILE ".remote-copilot-mcp"
-$BinDir  = Join-Path $DataDir "bin"
-$Binary  = Join-Path $BinDir "sensorium-supervisor.exe"
-
-# Find the supervisor source directory (relative to this script)
-$ScriptDir = Split-Path -Parent $MyInvocation.MyCommand.Path
-$SupervisorDir = Join-Path (Split-Path -Parent $ScriptDir) "supervisor"
-
-if (-not (Test-Path (Join-Path $SupervisorDir "go.mod"))) {
-    Write-Error "Cannot find supervisor source at $SupervisorDir"
-    exit 1
-}
-
-# Check if Go is available
-$goExe = Get-Command go -ErrorAction SilentlyContinue
-if (-not $goExe) {
-    Write-Host "Go is not installed. Install from https://go.dev/dl/ (requires Go 1.22+)" -ForegroundColor Red
-    exit 1
-}
-
-# Check version
-$goVersion = (go version) -replace 'go version go', '' -replace ' .*', ''
-Write-Host "Found Go $goVersion"
-
-# Skip build if binary exists and is newer than source (unless -Force)
-if (-not $Force -and (Test-Path $Binary)) {
-    $binaryTime = (Get-Item $Binary).LastWriteTime
-    $sourceFiles = Get-ChildItem $SupervisorDir -Filter "*.go"
-    $newestSource = ($sourceFiles | Sort-Object LastWriteTime -Descending | Select-Object -First 1).LastWriteTime
-    if ($binaryTime -gt $newestSource) {
-        Write-Host "sensorium-supervisor is up to date ($Binary)"
-        exit 0
-    }
-}
-
-# Ensure bin directory exists
-New-Item -ItemType Directory -Path $BinDir -Force | Out-Null
-
-Write-Host "Building sensorium-supervisor..."
-Push-Location $SupervisorDir
-try {
-    go build -o $Binary .
-    if ($LASTEXITCODE -ne 0) {
-        Write-Error "Go build failed"
-        exit 1
-    }
-} finally {
-    Pop-Location
-}
-
-Write-Host "Installed: $Binary" -ForegroundColor Green

package/scripts/install-supervisor.sh

@@ -1,43 +0,0 @@
-#!/bin/sh
-# Build and install the sensorium-supervisor Go binary.
-# Requires Go 1.22+ installed and on PATH.
-set -e
-
-FORCE="${1:-}"
-DATA_DIR="$HOME/.remote-copilot-mcp"
-BIN_DIR="$DATA_DIR/bin"
-BINARY="$BIN_DIR/sensorium-supervisor"
-
-# Find supervisor source relative to this script
-SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
-SUPERVISOR_DIR="$(dirname "$SCRIPT_DIR")/supervisor"
-
-if [ ! -f "$SUPERVISOR_DIR/go.mod" ]; then
-    echo "ERROR: Cannot find supervisor source at $SUPERVISOR_DIR" >&2
-    exit 1
-fi
-
-# Check Go is available
-if ! command -v go >/dev/null 2>&1; then
-    echo "ERROR: Go is not installed. Install from https://go.dev/dl/ (requires Go 1.22+)" >&2
-    exit 1
-fi
-
-echo "Found $(go version)"
-
-# Skip if binary is newer than source (unless --force)
-if [ "$FORCE" != "--force" ] && [ -f "$BINARY" ]; then
-    NEWEST_SRC=$(find "$SUPERVISOR_DIR" -name '*.go' -newer "$BINARY" 2>/dev/null | head -1)
-    if [ -z "$NEWEST_SRC" ]; then
-        echo "sensorium-supervisor is up to date ($BINARY)"
-        exit 0
-    fi
-fi
-
-mkdir -p "$BIN_DIR"
-
-echo "Building sensorium-supervisor..."
-cd "$SUPERVISOR_DIR"
-go build -o "$BINARY" .
-
-echo "Installed: $BINARY"

package/scripts/start-supervisor.ps1

@@ -1,46 +0,0 @@
-#!/usr/bin/env pwsh
-<#
-.SYNOPSIS
-    Launch sensorium-supervisor. Builds automatically if needed.
-.DESCRIPTION
-    Replaces update-watcher.ps1. Builds the Go supervisor if it doesn't exist,
-    then runs it. All environment variables (MCP_HTTP_PORT, TELEGRAM_TOKEN, etc.)
-    are passed through to the supervisor process.
-.PARAMETER Mode
-    Watcher mode: production or development. Maps to WATCHER_MODE env var.
-.PARAMETER Build
-    Force rebuild of the supervisor binary before starting.
-#>
-param(
-    [ValidateSet("production", "development")]
-    [string]$Mode = "production",
-    [switch]$Build
-)
-
-$ErrorActionPreference = "Stop"
-
-$DataDir = Join-Path $env:USERPROFILE ".remote-copilot-mcp"
-$BinDir  = Join-Path $DataDir "bin"
-$Binary  = Join-Path $BinDir "sensorium-supervisor.exe"
-$ScriptDir = Split-Path -Parent $MyInvocation.MyCommand.Path
-
-# Build if missing or requested
-if ($Build -or -not (Test-Path $Binary)) {
-    $installScript = Join-Path $ScriptDir "install-supervisor.ps1"
-    if ($Build) {
-        & $installScript -Force
-    } else {
-        & $installScript
-    }
-    if ($LASTEXITCODE -ne 0) { exit 1 }
-}
-
-# Set WATCHER_MODE if not already set
-if (-not $env:WATCHER_MODE) {
-    $env:WATCHER_MODE = $Mode
-}
-
-# Launch supervisor
-Write-Host "Starting sensorium-supervisor ($Mode mode)..."
-& $Binary
-exit $LASTEXITCODE

package/scripts/start-supervisor.sh

@@ -1,20 +0,0 @@
-#!/bin/sh
-# Launch sensorium-supervisor. Builds automatically if needed.
-# Replaces update-watcher.ps1 on Unix systems.
-set -e
-
-MODE="${1:-production}"
-DATA_DIR="$HOME/.remote-copilot-mcp"
-BIN_DIR="$DATA_DIR/bin"
-BINARY="$BIN_DIR/sensorium-supervisor"
-SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
-
-# Build if missing
-if [ ! -f "$BINARY" ]; then
-    "$SCRIPT_DIR/install-supervisor.sh"
-fi
-
-export WATCHER_MODE="${WATCHER_MODE:-$MODE}"
-
-echo "Starting sensorium-supervisor ($WATCHER_MODE mode)..."
-exec "$BINARY"