sensorium-mcp 2.17.26 → 2.17.28

package/supervisor/process_windows.go

@@ -0,0 +1,15 @@
+//go:build windows
+
+package main
+
+import (
+	"os/exec"
+	"syscall"
+)
+
+func setSysProcAttr(cmd *exec.Cmd) {
+	cmd.SysProcAttr = &syscall.SysProcAttr{
+		CreationFlags: syscall.CREATE_NEW_PROCESS_GROUP,
+		HideWindow:    true,
+	}
+}

package/supervisor/updater.go

@@ -0,0 +1,281 @@
+package main
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"time"
+)
+
+const registryURL = "https://registry.npmjs.org/sensorium-mcp/latest"
+
+// Updater checks the npm registry for new versions and performs updates.
+type Updater struct {
+	cfg     Config
+	mcp     *MCPClient
+	log     *Logger
+	startAt time.Time
+	cancel  context.CancelFunc
+	done    chan struct{}
+}
+
+func NewUpdater(cfg Config, mcp *MCPClient, log *Logger) *Updater {
+	return &Updater{
+		cfg:     cfg,
+		mcp:     mcp,
+		log:     log,
+		startAt: time.Now(),
+		done:    make(chan struct{}),
+	}
+}
+
+// Start begins the update check loop.
+func (u *Updater) Start() {
+	ctx, cancel := context.WithCancel(context.Background())
+	u.cancel = cancel
+	go u.run(ctx)
+}
+
+// Stop signals the updater to shut down and waits.
+func (u *Updater) Stop() {
+	if u.cancel != nil {
+		u.cancel()
+	}
+	<-u.done
+}
+
+func (u *Updater) run(ctx context.Context) {
+	defer close(u.done)
+	u.log.Info("Updater started (mode=%s)", u.cfg.Mode)
+
+	// In development mode, check every PollInterval.
+	// In production, check once per day at PollAtHour.
+	for {
+		var sleepDuration time.Duration
+		if u.cfg.Mode == "development" {
+			sleepDuration = u.cfg.PollInterval
+		} else {
+			sleepDuration = u.timeUntilNextPoll()
+		}
+		u.log.Debug("Updater: next version check in %v", sleepDuration.Round(time.Second))
+
+		select {
+		case <-ctx.Done():
+			return
+		case <-time.After(sleepDuration):
+		}
+
+		if ctx.Err() != nil {
+			return
+		}
+
+		u.checkAndUpdate(ctx)
+	}
+}
+
+func (u *Updater) timeUntilNextPoll() time.Duration {
+	now := time.Now()
+	next := time.Date(now.Year(), now.Month(), now.Day(), u.cfg.PollAtHour, 0, 0, 0, now.Location())
+	if next.Before(now) {
+		next = next.Add(24 * time.Hour)
+	}
+	return time.Until(next)
+}
+
+// getRemoteVersion fetches the latest version from npm registry.
+func (u *Updater) getRemoteVersion(ctx context.Context) (string, error) {
+	ctx2, cancel := context.WithTimeout(ctx, 15*time.Second)
+	defer cancel()
+
+	req, err := http.NewRequestWithContext(ctx2, "GET", registryURL, nil)
+	if err != nil {
+		return "", err
+	}
+
+	resp, err := http.DefaultClient.Do(req)
+	if err != nil {
+		return "", err
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != 200 {
+		return "", fmt.Errorf("npm registry HTTP %d", resp.StatusCode)
+	}
+
+	var pkg struct {
+		Version string `json:"version"`
+	}
+	if err := json.NewDecoder(resp.Body).Decode(&pkg); err != nil {
+		return "", err
+	}
+	return pkg.Version, nil
+}
+
+// getLocalVersion reads the current version from the version file.
+func (u *Updater) getLocalVersion() string {
+	data, err := os.ReadFile(u.cfg.Paths.VersionFile)
+	if err != nil {
+		return ""
+	}
+	return strings.TrimSpace(string(data))
+}
+
+func (u *Updater) setLocalVersion(v string) {
+	os.MkdirAll(u.cfg.DataDir, 0755)
+	if err := atomicWrite(u.cfg.Paths.VersionFile, []byte(v)); err != nil {
+		u.log.Warn("Failed to write version file: %v", err)
+	}
+}
+
+func (u *Updater) checkAndUpdate(ctx context.Context) {
+	// Enforce minimum uptime before updating
+	uptime := time.Since(u.startAt)
+	if uptime < u.cfg.MinUptime {
+		u.log.Info("Deferring update — too early (uptime %v < %v)", uptime.Round(time.Second), u.cfg.MinUptime)
+		return
+	}
+
+	remote, err := u.getRemoteVersion(ctx)
+	if err != nil {
+		u.log.Warn("Failed to check npm registry: %v", err)
+		return
+	}
+
+	local := u.getLocalVersion()
+	if local == "" {
+		u.log.Info("No local version recorded — storing %s", remote)
+		u.setLocalVersion(remote)
+		return
+	}
+
+	if local == remote {
+		u.log.Debug("Updater: version %s is up to date", local)
+		return
+	}
+
+	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)
+
+	// Grace period
+	u.log.Info("Grace period %v...", u.cfg.GracePeriod)
+	select {
+	case <-ctx.Done():
+		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 {
+		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 {
+		return
+	}
+	u.killServer()
+
+	// Clean npx cache
+	if ctx.Err() != nil {
+		return
+	}
+	u.clearNpxCache()
+
+	// Spawn new server — retry up to 3 times on failure
+	var pid int
+	for attempt := 1; attempt <= 3; attempt++ {
+		if ctx.Err() != nil {
+			return
+		}
+		pid, err = SpawnMCPServer(u.cfg, u.log)
+		if err == nil {
+			break
+		}
+		u.log.Error("Failed to spawn updated MCP server (attempt %d/3): %v", attempt, err)
+		if attempt < 3 {
+			time.Sleep(2 * time.Second)
+		}
+	}
+	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)
+		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")
+	}
+
+	u.setLocalVersion(remote)
+
+	NotifyOperator(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) killServer() {
+	u.log.Info("Updater: stopping current MCP server for update")
+	pid, err := ReadPIDFile(u.cfg.Paths.ServerPID)
+	if err != nil {
+		u.log.Warn("Could not read server PID file: %v", err)
+		// Try killing by port as fallback
+		KillByPort(u.cfg.MCPHttpPort, u.log)
+		return
+	}
+	if err := KillProcess(pid, u.log); err != nil {
+		u.log.Error("Failed to kill server (PID %d): %v", pid, err)
+		KillByPort(u.cfg.MCPHttpPort, u.log)
+	}
+}
+
+// clearNpxCache removes the cached sensorium-mcp package from the npx cache
+// so the next `npx -y sensorium-mcp@latest` fetches the new version.
+func (u *Updater) clearNpxCache() {
+	u.log.Info("Updater: clearing npx cache")
+	var base string
+	if runtime.GOOS == "windows" {
+		localAppData := os.Getenv("LOCALAPPDATA")
+		if localAppData == "" {
+			home, _ := os.UserHomeDir()
+			localAppData = filepath.Join(home, "AppData", "Local")
+		}
+		base = filepath.Join(localAppData, "npm-cache", "_npx")
+	} else {
+		home, _ := os.UserHomeDir()
+		base = filepath.Join(home, ".npm", "_npx")
+	}
+
+	u.log.Info("Clearing sensorium-mcp from npx cache (%s)", base)
+
+	entries, err := os.ReadDir(base)
+	if err != nil {
+		return
+	}
+
+	for _, e := range entries {
+		if !e.IsDir() {
+			continue
+		}
+		pkgDir := filepath.Join(base, e.Name(), "node_modules", "sensorium-mcp")
+		// Validate path doesn't escape base directory
+		if !strings.HasPrefix(pkgDir, base) {
+			continue
+		}
+		if _, err := os.Stat(pkgDir); err == nil {
+			if err := os.RemoveAll(pkgDir); err != nil {
+				u.log.Warn("Failed to clear npx cache entry %s: %v", pkgDir, err)
+			}
+		}
+	}
+}

package/dist/claude-keeper.d.ts

@@ -1,24 +0,0 @@
-/**
- * Thread keeper — monitors keep-alive threads and restarts them
- * via the start_thread MCP tool when they stop running.
- *
- * No direct process spawning — delegates to start_thread which handles
- * all lifecycle concerns (PID tracking, registry updates, MCP config).
- */
-export interface KeeperConfig {
-    threadId: number;
-    sessionName: string;
-    client: string;
-    mcpHttpPort: number;
-    mcpHttpSecret: string | null;
-    workingDirectory?: string;
-    maxRetries?: number;
-    cooldownMs?: number;
-    /** Called when the keeper detects the thread process has died. */
-    onDeath?: (threadId: number, sessionName: string) => void;
-}
-export interface KeeperHandle {
-    stop(): Promise<void>;
-}
-export declare function startClaudeKeeper(config: KeeperConfig): Promise<KeeperHandle>;
-//# sourceMappingURL=claude-keeper.d.ts.map

package/dist/claude-keeper.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"claude-keeper.d.ts","sourceRoot":"","sources":["../src/claude-keeper.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAuBH,MAAM,WAAW,YAAY;IAC3B,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,EAAE,MAAM,CAAC;IACpB,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,kEAAkE;IAClE,OAAO,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,KAAK,IAAI,CAAC;CAC3D;AAED,MAAM,WAAW,YAAY;IAC3B,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACvB;AA4OD,wBAAsB,iBAAiB,CAAC,MAAM,EAAE,YAAY,GAAG,OAAO,CAAC,YAAY,CAAC,CAgHnF"}

package/dist/claude-keeper.js

@@ -1,374 +0,0 @@
-/**
- * Thread keeper — monitors keep-alive threads and restarts them
- * via the start_thread MCP tool when they stop running.
- *
- * No direct process spawning — delegates to start_thread which handles
- * all lifecycle concerns (PID tracking, registry updates, MCP config).
- */
-import { LATEST_PROTOCOL_VERSION } from "@modelcontextprotocol/sdk/types.js";
-import { readFileSync } from "node:fs";
-import { homedir } from "node:os";
-import { join } from "node:path";
-import { errorMessage } from "./utils.js";
-// ─── Constants ───────────────────────────────────────────────────────────────
-const BASE_BACKOFF_MS = 5_000;
-const MAX_BACKOFF_MS = 5 * 60_000;
-const HEALTH_CHECK_INTERVAL_MS = 2 * 60_000;
-const DEFAULT_MAX_RETRIES = 5;
-const DEFAULT_COOLDOWN_MS = 300_000;
-const MCP_READY_POLL_INTERVAL_MS = 3_000;
-const MCP_READY_TIMEOUT_MS = 120_000;
-const FAST_EXIT_THRESHOLD_MS = 60_000; // process died within 60s = fast exit
-const FAST_EXIT_MAX_COUNT = 3; // 3 fast exits = escalating cooldown
-const FAST_EXIT_BASE_COOLDOWN_MS = 10 * 60_000; // 10 min initial, doubles each time
-// ─── Helpers ──────────────────────────────────────────────────────────────────
-function keeperLog(level, msg) {
-    const ts = new Date().toISOString();
-    console.log(`[${ts}] [KEEPER/${level}] ${msg}`);
-}
-function authHeaders(secret) {
-    const h = {
-        "Content-Type": "application/json",
-        "Accept": "application/json, text/event-stream",
-    };
-    if (secret)
-        h["Authorization"] = `Bearer ${secret}`;
-    return h;
-}
-/**
- * Parse a fetch Response that may be JSON or SSE (text/event-stream).
- * The MCP Streamable HTTP transport returns SSE when the Accept header
- * includes text/event-stream. Each SSE "data:" line contains a JSON-RPC
- * message. We extract the last data line as the result.
- */
-async function parseJsonOrSse(res) {
-    const ct = res.headers.get("content-type") ?? "";
-    if (ct.includes("text/event-stream")) {
-        const text = await res.text();
-        // Extract all "data:" lines and parse the last one (the final result)
-        const dataLines = text.split("\n")
-            .filter(line => line.startsWith("data:"))
-            .map(line => line.slice(5).trim());
-        for (let i = dataLines.length - 1; i >= 0; i--) {
-            try {
-                return JSON.parse(dataLines[i]);
-            }
-            catch { /* try previous line */ }
-        }
-        return {};
-    }
-    return await res.json();
-}
-async function waitForMcpReady(port, secret) {
-    const deadline = Date.now() + MCP_READY_TIMEOUT_MS;
-    while (Date.now() < deadline) {
-        try {
-            const res = await fetch(`http://127.0.0.1:${port}/api/threads/roots`, {
-                headers: authHeaders(secret),
-                signal: AbortSignal.timeout(5_000),
-            });
-            if (res.ok)
-                return true;
-        }
-        catch { /* server not ready */ }
-        await new Promise(r => setTimeout(r, MCP_READY_POLL_INTERVAL_MS));
-    }
-    return false;
-}
-async function isThreadRunning(port, secret, threadId) {
-    try {
-        const res = await fetch(`http://127.0.0.1:${port}/api/threads/${threadId}/running`, {
-            headers: authHeaders(secret),
-            signal: AbortSignal.timeout(5_000),
-        });
-        if (!res.ok)
-            return false;
-        const data = await res.json();
-        return data.running === true;
-    }
-    catch {
-        return false;
-    }
-}
-const STUCK_THRESHOLD_MS = 10 * 60_000; // 10 minutes without MCP activity = stuck
-async function isThreadStuck(port, secret, threadId) {
-    try {
-        const res = await fetch(`http://127.0.0.1:${port}/api/threads/${threadId}/heartbeat`, {
-            headers: authHeaders(secret),
-            signal: AbortSignal.timeout(5_000),
-        });
-        if (!res.ok)
-            return false;
-        const data = await res.json();
-        if (data.lastActivity == null)
-            return false; // no heartbeat yet, just started
-        return Date.now() - data.lastActivity > STUCK_THRESHOLD_MS;
-    }
-    catch {
-        return false;
-    }
-}
-async function killThread(port, secret, threadId) {
-    // Read PID file and kill the process directly
-    try {
-        const pidFile = join(homedir(), ".remote-copilot-mcp", "pids", `${threadId}.pid`);
-        const raw = readFileSync(pidFile, "utf-8").trim();
-        let pid;
-        try {
-            pid = JSON.parse(raw).pid;
-        }
-        catch {
-            pid = Number(raw);
-        }
-        if (Number.isFinite(pid)) {
-            if (process.platform === "win32") {
-                // On Windows, process.kill throws EPERM for child processes.
-                // Use taskkill which works reliably.
-                const { execSync } = await import("child_process");
-                try {
-                    execSync(`taskkill /F /T /PID ${pid}`, { stdio: "ignore", timeout: 10_000 });
-                }
-                catch { /* already dead */ }
-            }
-            else {
-                try {
-                    process.kill(pid, "SIGKILL");
-                }
-                catch { /* already dead */ }
-            }
-            keeperLog("INFO", `Killed stuck process PID=${pid} for thread ${threadId}`);
-        }
-    }
-    catch { /* PID file missing or unreadable */ }
-}
-async function openMcpSession(port, secret) {
-    try {
-        const res = await fetch(`http://127.0.0.1:${port}/mcp`, {
-            method: "POST",
-            headers: authHeaders(secret),
-            body: JSON.stringify({
-                jsonrpc: "2.0",
-                id: `keeper-init-${Date.now()}`,
-                method: "initialize",
-                params: {
-                    protocolVersion: LATEST_PROTOCOL_VERSION,
-                    capabilities: {},
-                    clientInfo: {
-                        name: "thread-keeper",
-                        version: "1.0.0",
-                    },
-                },
-            }),
-            signal: AbortSignal.timeout(30_000),
-        });
-        if (!res.ok) {
-            keeperLog("WARN", `initialize HTTP ${res.status}: ${res.statusText}`);
-            return null;
-        }
-        // Consume the body (may be SSE or JSON) to avoid connection stalls
-        await res.text();
-        const sessionId = res.headers.get("mcp-session-id");
-        if (!sessionId) {
-            keeperLog("WARN", "initialize succeeded but did not return an MCP session ID");
-            return null;
-        }
-        await fetch(`http://127.0.0.1:${port}/mcp`, {
-            method: "POST",
-            headers: {
-                ...authHeaders(secret),
-                "mcp-session-id": sessionId,
-            },
-            body: JSON.stringify({
-                jsonrpc: "2.0",
-                method: "notifications/initialized",
-                params: {},
-            }),
-            signal: AbortSignal.timeout(30_000),
-        });
-        return sessionId;
-    }
-    catch (err) {
-        keeperLog("ERROR", `initialize failed: ${errorMessage(err)}`);
-        return null;
-    }
-}
-async function closeMcpSession(port, secret, sessionId) {
-    try {
-        await fetch(`http://127.0.0.1:${port}/mcp`, {
-            method: "DELETE",
-            headers: {
-                ...authHeaders(secret),
-                "mcp-session-id": sessionId,
-            },
-            signal: AbortSignal.timeout(10_000),
-        });
-    }
-    catch {
-        // Best-effort cleanup.
-    }
-}
-async function callStartThread(config) {
-    const { mcpHttpPort: port, mcpHttpSecret: secret, threadId, sessionName, client, workingDirectory } = config;
-    const sessionId = await openMcpSession(port, secret);
-    if (!sessionId)
-        return false;
-    try {
-        const body = JSON.stringify({
-            jsonrpc: "2.0",
-            method: "tools/call",
-            params: {
-                name: "start_thread",
-                arguments: {
-                    name: sessionName,
-                    targetThreadId: threadId,
-                    agentType: client,
-                    mode: "resume",
-                    ...(workingDirectory !== undefined ? { workingDirectory } : {}),
-                },
-            },
-            id: `keeper-${threadId}-${Date.now()}`,
-        });
-        const res = await fetch(`http://127.0.0.1:${port}/mcp`, {
-            method: "POST",
-            headers: {
-                ...authHeaders(secret),
-                "mcp-session-id": sessionId,
-            },
-            body,
-            signal: AbortSignal.timeout(30_000),
-        });
-        if (!res.ok) {
-            keeperLog("WARN", `start_thread HTTP ${res.status}: ${res.statusText}`);
-            return false;
-        }
-        const result = await parseJsonOrSse(res);
-        if (result.error) {
-            keeperLog("WARN", `start_thread RPC error ${result.error.code ?? "unknown"}: ${result.error.message ?? "unknown error"}`);
-            return false;
-        }
-        const text = result?.result?.content?.[0]?.text ?? "";
-        if (!text.trim()) {
-            keeperLog("WARN", "start_thread returned an empty response");
-            return false;
-        }
-        keeperLog("INFO", `start_thread response: ${text.slice(0, 200)}`);
-        return !text.toLowerCase().includes("error");
-    }
-    catch (err) {
-        keeperLog("ERROR", `start_thread call failed: ${errorMessage(err)}`);
-        return false;
-    }
-    finally {
-        await closeMcpSession(port, secret, sessionId);
-    }
-}
-// ─── Core keeper ──────────────────────────────────────────────────────────────
-export async function startClaudeKeeper(config) {
-    const maxRetries = config.maxRetries ?? DEFAULT_MAX_RETRIES;
-    const cooldownMs = config.cooldownMs ?? DEFAULT_COOLDOWN_MS;
-    keeperLog("INFO", `Starting keeper for thread ${config.threadId} ('${config.sessionName}') [client=${config.client}]`);
-    let stopped = false;
-    let retryCount = 0;
-    let consecutiveNotRunning = 0;
-    let consecutiveStuck = 0;
-    let timer = null;
-    let lastStartTime = 0; // epoch ms when the last process was started
-    let fastExitCount = 0; // consecutive fast exits (< 60s lifetime)
-    let fastExitEscalation = 0; // escalation level for exponential backoff
-    keeperLog("INFO", "Waiting for MCP server to be ready...");
-    const ready = await waitForMcpReady(config.mcpHttpPort, config.mcpHttpSecret);
-    if (!ready)
-        keeperLog("WARN", "MCP server did not respond in time — attempting start_thread anyway.");
-    else
-        keeperLog("INFO", "MCP server ready.");
-    async function checkAndStart() {
-        if (stopped)
-            return;
-        const running = await isThreadRunning(config.mcpHttpPort, config.mcpHttpSecret, config.threadId);
-        if (running) {
-            consecutiveNotRunning = 0;
-            // Check for stuck process (alive but no MCP activity for 10+ min)
-            const stuck = await isThreadStuck(config.mcpHttpPort, config.mcpHttpSecret, config.threadId);
-            if (stuck) {
-                consecutiveStuck++;
-                if (consecutiveStuck < 3) {
-                    // Require 3 consecutive stuck checks (~6 min) before killing
-                    keeperLog("INFO", `Thread ${config.threadId} appears stuck (${consecutiveStuck}/3) — rechecking in 2 min`);
-                    scheduleCheck();
-                    return;
-                }
-                keeperLog("WARN", `Thread ${config.threadId} confirmed stuck (no MCP activity for ${STUCK_THRESHOLD_MS / 60_000}+ min, ${consecutiveStuck} checks) — killing process`);
-                await killThread(config.mcpHttpPort, config.mcpHttpSecret, config.threadId);
-                consecutiveStuck = 0;
-                // Wait for process to actually die, then restart on next normal check
-                scheduleCheck();
-                return;
-            }
-            consecutiveStuck = 0;
-            scheduleCheck();
-            return;
-        }
-        consecutiveNotRunning++;
-        if (consecutiveNotRunning === 1) {
-            // First detection — notify operator immediately
-            config.onDeath?.(config.threadId, config.sessionName);
-        }
-        if (consecutiveNotRunning < 2) {
-            // Single failure may be a timeout; recheck quickly before restarting
-            timer = setTimeout(() => void checkAndStart(), 10_000);
-            return;
-        }
-        if (retryCount >= maxRetries) {
-            keeperLog("WARN", `Max retries (${maxRetries}) exceeded — cooling down for ${Math.round(cooldownMs / 1000)}s`);
-            retryCount = 0;
-            timer = setTimeout(() => void checkAndStart(), cooldownMs);
-            return;
-        }
-        retryCount++;
-        keeperLog("INFO", `Thread ${config.threadId} not running — calling start_thread (attempt ${retryCount}/${maxRetries})`);
-        // Fast-exit detection: if the process died quickly, use exponential backoff.
-        if (lastStartTime > 0 && (Date.now() - lastStartTime) < FAST_EXIT_THRESHOLD_MS) {
-            fastExitCount++;
-            if (fastExitCount >= FAST_EXIT_MAX_COUNT) {
-                const cooldown = Math.min(FAST_EXIT_BASE_COOLDOWN_MS * 2 ** fastExitEscalation, 4 * 60 * 60_000); // cap 4h
-                fastExitEscalation++;
-                keeperLog("WARN", `Thread ${config.threadId}: ${fastExitCount} consecutive fast exits — backing off ${Math.round(cooldown / 60_000)} min`);
-                config.onDeath?.(config.threadId, `${config.sessionName} (repeated fast exits — check credits/API key)`);
-                fastExitCount = 0;
-                retryCount = 0;
-                timer = setTimeout(() => void checkAndStart(), cooldown);
-                return;
-            }
-        }
-        else {
-            fastExitCount = 0;
-            fastExitEscalation = 0; // reset if the process ran long enough
-        }
-        lastStartTime = Date.now();
-        const ok = await callStartThread(config);
-        if (ok) {
-            retryCount = 0;
-            consecutiveNotRunning = 0;
-            scheduleCheck();
-        }
-        else {
-            const delay = Math.min(BASE_BACKOFF_MS * 2 ** retryCount, MAX_BACKOFF_MS);
-            keeperLog("INFO", `Scheduling retry in ${delay}ms`);
-            timer = setTimeout(() => void checkAndStart(), delay);
-        }
-    }
-    function scheduleCheck() {
-        if (stopped)
-            return;
-        timer = setTimeout(() => void checkAndStart(), HEALTH_CHECK_INTERVAL_MS);
-    }
-    void checkAndStart();
-    return {
-        async stop() {
-            stopped = true;
-            if (timer)
-                clearTimeout(timer);
-        },
-    };
-}
-//# sourceMappingURL=claude-keeper.js.map