sensorium-mcp 2.17.26 → 2.17.27

package/dist/watcher-service.js

@@ -1,997 +0,0 @@
-/** Watcher Service — Node.js replacement for update-watcher.ps1. Run: npx sensorium-mcp --watcher */
-import { execSync, spawn, spawnSync } from "node:child_process";
-import { closeSync, existsSync, mkdirSync, openSync, readFileSync, readdirSync, renameSync, rmSync, statSync, writeFileSync, writeSync, unlinkSync } from "node:fs";
-import { createServer } from "node:http";
-import { homedir } from "node:os";
-import { join } from "node:path";
-import { randomUUID } from "node:crypto";
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
-import { CallToolRequestSchema, isInitializeRequest, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
-import { startClaudeKeeper } from "./claude-keeper.js";
-import { cleanupExpiredWorkers } from "./tools/thread-lifecycle.js";
-import { initMemoryDb } from "./data/memory/schema.js";
-import { errorMessage } from "./utils.js";
-process.on("uncaughtException", (err) => {
-    console.error(`[fatal] Uncaught exception: ${err.stack ?? err}`);
-    process.exit(1);
-});
-process.on("unhandledRejection", (reason) => {
-    console.error(`[fatal] Unhandled rejection: ${reason instanceof Error ? reason.stack : reason}`);
-    process.exit(1);
-});
-// Configuration ---------------------------------------------------------------
-const CONFIG = {
-    mode: process.env.WATCHER_MODE || "development",
-    pollAtHour: parseInt(process.env.WATCHER_POLL_HOUR || "4", 10),
-    pollIntervalSeconds: parseInt(process.env.WATCHER_POLL_INTERVAL || "60", 10),
-    gracePeriodSeconds: parseInt(process.env.WATCHER_GRACE_PERIOD || ((process.env.WATCHER_MODE || "development") === "development" ? "10" : "300"), 10),
-    idleThresholdSeconds: 300, maxIdleWaitSeconds: 300,
-    minUptimeSeconds: 600,
-    httpPort: parseInt(process.env.WATCHER_PORT || "3848", 10),
-    mcpStartCommand: process.env.MCP_START_COMMAND || "npx -y sensorium-mcp@latest",
-    dataDir: join(homedir(), ".remote-copilot-mcp"),
-    // Always-on CLI keeper
-    mcpHttpPort: parseInt(process.env.MCP_HTTP_PORT || "0", 10),
-    mcpHttpSecret: process.env.MCP_HTTP_SECRET || null,
-};
-const P = {
-    flag: join(CONFIG.dataDir, "maintenance.flag"), ver: join(CONFIG.dataDir, "current-version.txt"),
-    activity: join(CONFIG.dataDir, "last-activity.txt"), pid: join(CONFIG.dataDir, "server.pid"),
-    lock: join(CONFIG.dataDir, "watcher.lock"),
-};
-let startTime = Date.now();
-let managedChild = null;
-let httpSrv = null;
-let updateInProgress = false;
-let consecutiveHealthFailures = 0;
-const HEALTH_FAIL_THRESHOLD = 3;
-const keepers = new Map();
-let keeperPollerHandle = null;
-let sessionSweeperHandle = null;
-let workerCleanupHandle = null;
-// Helpers ---------------------------------------------------------------------
-let _logFd = null;
-function getLogFd() {
-    if (_logFd !== null)
-        return _logFd;
-    try {
-        ensureDir();
-        const logPath = join(CONFIG.dataDir, "watcher.log");
-        _logFd = openSync(logPath, "a");
-        return _logFd;
-    }
-    catch {
-        return null;
-    }
-}
-function log(level, msg) {
-    const text = msg instanceof Error ? `${msg.message}\n${msg.stack}` : String(msg);
-    const line = `[${new Date().toISOString().replace("T", " ").slice(0, 19)}] [${level}] ${text}`;
-    console.log(line);
-    try {
-        const fd = getLogFd();
-        if (fd !== null)
-            writeSync(fd, line + "\n");
-    }
-    catch { /* best-effort file logging */ }
-}
-function sleep(ms) { return new Promise((r) => setTimeout(r, ms)); }
-function ensureDir() { if (!existsSync(CONFIG.dataDir))
-    mkdirSync(CONFIG.dataDir, { recursive: true }); }
-function uptimeS() { return (Date.now() - startTime) / 1000; }
-// ── Lightweight Telegram notification (no dependency on telegram.ts) ─────────
-const TG_TOKEN = process.env.TELEGRAM_TOKEN ?? "";
-const TG_CHAT_ID = process.env.TELEGRAM_CHAT_ID ?? "";
-/**
- * Send a Telegram message from the watcher process.
- * Uses raw fetch against the Bot API — does not depend on the main server
- * or any agent connections. If token/chatId are missing, silently no-ops.
- */
-async function notifyOperator(text, threadId) {
-    if (!TG_TOKEN || !TG_CHAT_ID)
-        return;
-    try {
-        let resolvedThreadId = threadId;
-        if (threadId) {
-            try {
-                const { resolveTelegramTopicId } = await import("./data/memory/thread-registry.js");
-                const { initMemoryDb } = await import("./memory.js");
-                resolvedThreadId = resolveTelegramTopicId(initMemoryDb(), threadId);
-            }
-            catch { /* use original threadId as fallback */ }
-        }
-        const body = { chat_id: TG_CHAT_ID, text, parse_mode: "HTML" };
-        if (resolvedThreadId)
-            body.message_thread_id = resolvedThreadId;
-        await fetch(`https://api.telegram.org/bot${TG_TOKEN}/sendMessage`, {
-            method: "POST",
-            headers: { "Content-Type": "application/json" },
-            body: JSON.stringify(body),
-            signal: AbortSignal.timeout(10_000),
-        });
-    }
-    catch (err) {
-        log("WARN", `Telegram notify failed: ${errorMessage(err)}`);
-    }
-}
-function msUntilHour(h) {
-    const now = new Date(), t = new Date(now);
-    t.setHours(h, 0, 0, 0);
-    if (t.getTime() <= now.getTime())
-        t.setDate(t.getDate() + 1);
-    return t.getTime() - now.getTime();
-}
-function safeRead(p) {
-    try {
-        return existsSync(p) ? readFileSync(p, "utf-8").trim() || null : null;
-    }
-    catch {
-        return null;
-    }
-}
-function alive(pid) {
-    if (process.platform === "win32") {
-        try {
-            const result = spawnSync("tasklist", ["/FI", `PID eq ${pid}`, "/NH"], { encoding: "utf-8", timeout: 5000, windowsHide: true });
-            return result.status === 0 && new RegExp(`\\b${pid}\\b`).test(result.stdout);
-        }
-        catch {
-            return false;
-        }
-    }
-    try {
-        process.kill(pid, 0);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-/** Kill a single process without affecting its children. */
-async function killPidOnly(pid) {
-    if (process.platform === "win32") {
-        spawnSync("taskkill", ["/F", "/PID", String(pid)], { timeout: 10000, windowsHide: true });
-        await sleep(2000);
-        if (alive(pid)) {
-            spawnSync("taskkill", ["/F", "/PID", String(pid)], { timeout: 10000, windowsHide: true });
-        }
-    }
-    else {
-        try {
-            process.kill(pid, "SIGTERM");
-        }
-        catch { /**/ }
-        await sleep(2000);
-        if (alive(pid)) {
-            try {
-                process.kill(pid, "SIGKILL");
-            }
-            catch { /**/ }
-        }
-    }
-}
-/** Kill a process and its entire process tree. */
-async function killPidTree(pid) {
-    if (process.platform === "win32") {
-        // spawnSync instead of execSync: taskkill returns non-zero if ANY child
-        // can't be killed, causing execSync to throw even on partial success.
-        spawnSync("taskkill", ["/F", "/T", "/PID", String(pid)], { timeout: 10000, windowsHide: true });
-        await sleep(3000);
-        if (alive(pid)) {
-            spawnSync("taskkill", ["/F", "/T", "/PID", String(pid)], { timeout: 10000, windowsHide: true });
-        }
-    }
-    else {
-        try {
-            process.kill(pid, "SIGTERM");
-        }
-        catch { /**/ }
-        await sleep(2000);
-        if (alive(pid)) {
-            try {
-                process.kill(pid, "SIGKILL");
-            }
-            catch { /**/ }
-        }
-    }
-}
-function atomicWrite(path, data) {
-    const tmp = path + ".tmp";
-    writeFileSync(tmp, data, "utf-8");
-    renameSync(tmp, path);
-}
-// Version & flag management ---------------------------------------------------
-function getLocalVersion() { return safeRead(P.ver); }
-function setLocalVersion(v) { ensureDir(); atomicWrite(P.ver, v); }
-function writeMaintenanceFlag(v) {
-    ensureDir();
-    atomicWrite(P.flag, JSON.stringify({ version: v, timestamp: new Date().toISOString() }));
-    log("INFO", `Maintenance flag written for v${v}`);
-}
-function removeMaintenanceFlag() {
-    try {
-        if (existsSync(P.flag)) {
-            unlinkSync(P.flag);
-            log("INFO", "Maintenance flag removed.");
-        }
-    }
-    catch { /**/ }
-}
-function flagExists() { return existsSync(P.flag); }
-// Activity heartbeat ----------------------------------------------------------
-function activityAgeSec() {
-    const raw = safeRead(P.activity);
-    if (!raw)
-        return null;
-    const e = parseInt(raw, 10);
-    return Number.isNaN(e) ? null : (Date.now() - e) / 1000;
-}
-// Process management (PID file) -----------------------------------------------
-function readPid() {
-    const raw = safeRead(P.pid);
-    if (!raw)
-        return null;
-    const n = parseInt(raw, 10);
-    return Number.isNaN(n) ? null : n;
-}
-function writePid(pid) { ensureDir(); atomicWrite(P.pid, String(pid)); }
-function rmPid() { try {
-    if (existsSync(P.pid))
-        unlinkSync(P.pid);
-}
-catch { /**/ } }
-function startMcpServer() {
-    const parts = CONFIG.mcpStartCommand.split(/\s+/);
-    const cmd = parts[0];
-    const args = parts.slice(1);
-    log("INFO", `Starting MCP server: ${CONFIG.mcpStartCommand}`);
-    try {
-        const child = spawn(cmd, args, { stdio: "ignore", windowsHide: true, shell: true });
-        child.on("error", (err) => log("ERROR", `MCP server spawn error: ${err.message}`));
-        if (child.pid) {
-            writePid(child.pid);
-            managedChild = child;
-            child.unref();
-            log("INFO", `MCP server started (PID ${child.pid})`);
-        }
-    }
-    catch (err) {
-        log("ERROR", `Failed to start MCP server: ${err}`);
-    }
-}
-async function stopMcpServer() {
-    const pid = readPid();
-    if (pid && alive(pid)) {
-        log("INFO", `Stopping MCP server (PID ${pid})...`);
-        await killPidTree(pid);
-    }
-    rmPid();
-    managedChild = null;
-    // Fallback: kill whatever is listening on the MCP port.
-    // The PID file tracks the securevault wrapper, but the inner node.js process
-    // may survive if the wrapper exits first (detached process on Windows).
-    if (process.platform === "win32") {
-        try {
-            const port = CONFIG.mcpHttpPort || 3847;
-            const netstat = spawnSync("cmd", ["/c", `netstat -aon | findstr ":${port}.*LISTENING"`], { timeout: 5000, encoding: "utf8", windowsHide: true });
-            const m = (netstat.stdout || "").match(/\s(\d+)\s*$/m);
-            if (m) {
-                const orphanPid = parseInt(m[1], 10);
-                if (Number.isFinite(orphanPid) && orphanPid > 0) {
-                    log("INFO", `Killing orphan process PID=${orphanPid} still on port ${port}`);
-                    spawnSync("taskkill", ["/F", "/T", "/PID", String(orphanPid)], { timeout: 10000, windowsHide: true });
-                    await sleep(2000);
-                }
-            }
-        }
-        catch { /* no process on port — good */ }
-    }
-    log("INFO", `MCP server stopped.`);
-}
-// Server readiness check ------------------------------------------------------
-/** Poll the MCP HTTP server until it responds or 60s timeout. */
-async function waitForServerReady() {
-    const port = CONFIG.mcpHttpPort || 3847;
-    const deadline = Date.now() + 60_000;
-    while (Date.now() < deadline) {
-        try {
-            const res = await fetch(`http://127.0.0.1:${port}/mcp`, { method: "OPTIONS", signal: AbortSignal.timeout(2000) });
-            if (res.status < 500) {
-                log("INFO", "MCP server ready (HTTP responding).");
-                // On Windows with shell:true, the stored PID may be a transient cmd.exe.
-                // Update the PID file with the actual node process listening on the port.
-                if (process.platform === "win32") {
-                    try {
-                        const netstat = execSync(`netstat -aon | findstr ":${port}.*LISTENING"`, { timeout: 5000, encoding: "utf8" });
-                        const m = netstat.match(/\s(\d+)\s*$/m);
-                        if (m) {
-                            const realPid = parseInt(m[1], 10);
-                            const storedPid = readPid();
-                            if (realPid !== storedPid) {
-                                writePid(realPid);
-                                log("INFO", `Updated server PID: ${storedPid} → ${realPid}`);
-                            }
-                        }
-                    }
-                    catch { /**/ }
-                }
-                return;
-            }
-        }
-        catch { /* server not up yet */ }
-        await sleep(2000);
-    }
-    log("WARN", "MCP server did not respond within 60s — proceeding anyway.");
-}
-/** Single-shot HTTP liveness probe. Returns true if MCP server is responding. */
-async function isMcpServerHealthy() {
-    const port = CONFIG.mcpHttpPort || 3847;
-    try {
-        const res = await fetch(`http://127.0.0.1:${port}/mcp`, { method: "OPTIONS", signal: AbortSignal.timeout(3000) });
-        return res.status < 500;
-    }
-    catch {
-        return false;
-    }
-}
-// npx cache clearing ----------------------------------------------------------
-function clearNpxCache() {
-    const base = process.platform === "win32"
-        ? join(process.env.LOCALAPPDATA || join(homedir(), "AppData", "Local"), "npm-cache", "_npx")
-        : join(homedir(), ".npm", "_npx");
-    if (!existsSync(base))
-        return;
-    log("INFO", "Clearing sensorium-mcp from npx cache...");
-    try {
-        for (const e of readdirSync(base)) {
-            const pkgDir = join(base, e, "node_modules", "sensorium-mcp");
-            if (existsSync(pkgDir))
-                rmSync(pkgDir, { recursive: true, force: true });
-        }
-    }
-    catch (err) {
-        log("WARN", `Cache clear error: ${err}`);
-    }
-}
-// Stale process cleanup -------------------------------------------------------
-async function killStale() {
-    const pid = readPid();
-    if (!pid)
-        return;
-    if (!alive(pid)) {
-        rmPid();
-        return;
-    }
-    try {
-        if (!existsSync(P.ver) || !existsSync(P.pid))
-            return;
-        if (statSync(P.pid).mtimeMs < statSync(P.ver).mtimeMs - 60_000) {
-            log("WARN", `Killing stale PID ${pid}`);
-            await killPidTree(pid);
-            rmPid();
-        }
-    }
-    catch { /**/ }
-}
-// Registry check --------------------------------------------------------------
-const REGISTRY_URL = "https://registry.npmjs.org/sensorium-mcp/latest";
-// Ghost thread re-spawn helpers -----------------------------------------------
-/**
- * Parse a single PID file and return pid + name, or null if unparseable.
- */
-function parsePidFile(filePath) {
-    try {
-        const raw = readFileSync(filePath, "utf-8").trim();
-        try {
-            const meta = JSON.parse(raw);
-            return Number.isFinite(meta.pid) ? meta : null;
-        }
-        catch {
-            const pid = Number(raw);
-            return Number.isFinite(pid) ? { pid } : null;
-        }
-    }
-    catch {
-        return null;
-    }
-}
-/**
- * Clean up PID files for dead processes.
- */
-function readGhostThreads() {
-    const pidsDir = join(CONFIG.dataDir, "pids");
-    try {
-        for (const file of readdirSync(pidsDir)) {
-            if (!file.endsWith(".pid"))
-                continue;
-            const fullPath = join(pidsDir, file);
-            const parsed = parsePidFile(fullPath);
-            if (!parsed || !alive(parsed.pid)) {
-                try {
-                    unlinkSync(fullPath);
-                }
-                catch { /* ignore */ }
-            }
-        }
-    }
-    catch { /* pids dir may not exist */ }
-}
-/**
- * Kill all agent processes tracked in PID files and remove the files.
- * Called from the watcher (which runs outside securevault) because
- * the server's own execSync("taskkill") may fail within the securevault sandbox.
- */
-/** Clean up stale agent PID files. Agents are non-detached children of the
- *  server, so stopMcpServer() kills them via taskkill /F /T on the server PID.
- *  This just removes leftover PID files. */
-async function cleanAgentPidFiles() {
-    const pidsDir = join(CONFIG.dataDir, "pids");
-    try {
-        for (const file of readdirSync(pidsDir)) {
-            if (!file.endsWith(".pid"))
-                continue;
-            const fullPath = join(pidsDir, file);
-            const parsed = parsePidFile(fullPath);
-            if (!parsed) {
-                try {
-                    unlinkSync(fullPath);
-                }
-                catch { /**/ }
-                continue;
-            }
-            if (!alive(parsed.pid)) {
-                try {
-                    unlinkSync(fullPath);
-                }
-                catch { /**/ }
-            }
-        }
-    }
-    catch { /* pids dir may not exist */ }
-}
-async function getRemoteVersion() {
-    try {
-        const r = await fetch(REGISTRY_URL, { signal: AbortSignal.timeout(15_000) });
-        if (!r.ok) {
-            log("WARN", `Registry returned HTTP ${r.status}`);
-            return null;
-        }
-        return (await r.json()).version ?? null;
-    }
-    catch (err) {
-        log("ERROR", `Registry check failed: ${err}`);
-        return null;
-    }
-}
-// Update orchestration --------------------------------------------------------
-async function checkAndUpdate() {
-    if (updateInProgress) {
-        log("INFO", "Update already in progress, skipping");
-        return;
-    }
-    updateInProgress = true;
-    try {
-        if (uptimeS() > 120) {
-            // Use HTTP health probe instead of PID liveness — on Windows, shell: true
-            // gives back the transient shell PID, not the real MCP server process.
-            // The shell exits quickly, making alive(pid) return false even when the
-            // server is healthy, causing a false-restart loop.
-            if (!(await isMcpServerHealthy())) {
-                consecutiveHealthFailures++;
-                if (consecutiveHealthFailures >= HEALTH_FAIL_THRESHOLD) {
-                    log("WARN", `Server not running (${consecutiveHealthFailures} consecutive failures) — restarting...`);
-                    await notifyOperator("\u26A0\uFE0F Watcher: server process not running — restarting...");
-                    startMcpServer();
-                    startTime = Date.now();
-                    consecutiveHealthFailures = 0;
-                }
-                else {
-                    log("INFO", `Health check failed (${consecutiveHealthFailures}/${HEALTH_FAIL_THRESHOLD}), waiting...`);
-                }
-            }
-            else {
-                consecutiveHealthFailures = 0;
-            }
-        }
-        const remote = await getRemoteVersion();
-        if (!remote)
-            return;
-        const local = getLocalVersion();
-        if (!local) {
-            setLocalVersion(remote);
-            return;
-        }
-        if (remote === local) {
-            log("INFO", `Up to date: v${local}`);
-            return;
-        }
-        if (uptimeS() < CONFIG.minUptimeSeconds) {
-            log("INFO", "Deferring update — too early.");
-            return;
-        }
-        log("INFO", `Update: v${local} → v${remote}`);
-        await notifyOperator(`\u2699\uFE0F Watcher: updating sensorium v${local} \u2192 v${remote}. Grace period ${CONFIG.gracePeriodSeconds}s...`);
-        writeMaintenanceFlag(remote);
-        log("INFO", `Grace period ${CONFIG.gracePeriodSeconds}s...`);
-        await sleep(CONFIG.gracePeriodSeconds * 1000);
-        // Clean up stale PID files before killing the server
-        readGhostThreads();
-        await stopMcpServer();
-        await cleanAgentPidFiles();
-        clearNpxCache();
-        setLocalVersion(remote);
-        startMcpServer();
-        startTime = Date.now();
-        await waitForServerReady();
-        await killStale();
-        removeMaintenanceFlag();
-        // The new server spawns keepAlive threads on startup.
-        // Keepers detect crash-recovery needs via their regular poll cycle.
-        await notifyOperator(`\u2705 Watcher: update to v${remote} complete. Server ready.`);
-        log("INFO", `Update to v${remote} complete.`);
-    }
-    catch (err) {
-        log("ERROR", `Update failed: ${err}`);
-        removeMaintenanceFlag();
-        return; // Don't self-restart on failure
-    }
-    finally {
-        updateInProgress = false;
-    }
-    // Self-restart OUTSIDE try/finally so updateInProgress is always reset.
-    // selfRestart() calls process.exit() and never returns.
-    selfRestart();
-}
-// Claude CLI keeper -----------------------------------------------------------
-/** Spawn a new watcher process with fresh code and exit. */
-function selfRestart() {
-    log("INFO", "Self-restarting watcher to load new code...");
-    // Clean up keepers, timers, HTTP server
-    if (keeperPollerHandle)
-        clearInterval(keeperPollerHandle);
-    if (sessionSweeperHandle)
-        clearInterval(sessionSweeperHandle);
-    if (workerCleanupHandle)
-        clearInterval(workerCleanupHandle);
-    for (const [, entry] of keepers) {
-        void entry.handle.stop();
-    }
-    keepers.clear();
-    httpSrv?.close();
-    releaseLock();
-    // Re-run the same command that started this watcher.
-    // Use WATCHER_START_COMMAND env var if set, otherwise default.
-    // Redirect stdout/stderr to the watcher log file.
-    const logPath = join(CONFIG.dataDir, "watcher.log");
-    const logFd = openSync(logPath, "a");
-    const startCmd = process.env.WATCHER_START_COMMAND
-        || "securevault run npx -y sensorium-mcp@latest --watcher --prefer-online --profile SENSORIUM";
-    log("INFO", `Restart command: ${startCmd}`);
-    const child = spawn(startCmd, [], {
-        detached: true,
-        stdio: ["ignore", logFd, logFd],
-        shell: true,
-        windowsHide: true,
-    });
-    child.unref();
-    log("INFO", `New watcher spawned (PID ${child.pid}). Exiting old watcher.`);
-    process.exit(0);
-}
-const KEEPER_SETTINGS_POLL_MS = 2 * 60_000;
-/**
- * Read keeper settings from the thread_registry via the HTTP API.
- * Returns empty array if the server is not ready (keeper won't start until server is up).
- */
-async function readAllKeeperSettings() {
-    const port = CONFIG.mcpHttpPort || 3847;
-    try {
-        const res = await fetch(`http://127.0.0.1:${port}/api/threads`, {
-            headers: CONFIG.mcpHttpSecret ? { 'Authorization': `Bearer ${CONFIG.mcpHttpSecret}` } : {},
-            signal: AbortSignal.timeout(5_000),
-        });
-        if (!res.ok)
-            return null;
-        const body = (await res.json());
-        const all = body.threads ?? [];
-        return all
-            .filter((r) => r.keepAlive)
-            .filter((r) => Number.isInteger(r.threadId) && r.threadId > 0)
-            .map((r) => ({
-            enabled: true,
-            threadId: r.threadId,
-            maxRetries: (typeof r.maxRetries === 'number' ? r.maxRetries : null) ?? 5,
-            cooldownMs: (typeof r.cooldownMs === 'number' ? r.cooldownMs : null) ?? 300_000,
-            client: typeof r.client === 'string' ? r.client : 'claude',
-            sessionName: (typeof r.name === 'string' ? r.name : null) ?? `thread-${r.threadId}`,
-            workingDirectory: typeof r.workingDirectory === 'string' ? r.workingDirectory : undefined,
-        }));
-    }
-    catch {
-        return null;
-    }
-}
-function keeperSettingsChanged(a, b) {
-    return a.maxRetries !== b.maxRetries
-        || a.cooldownMs !== b.cooldownMs
-        || a.client !== b.client
-        || a.sessionName !== b.sessionName
-        || a.workingDirectory !== b.workingDirectory;
-}
-let applyingSettings = false;
-async function applyKeeperSettings() {
-    if (applyingSettings)
-        return;
-    applyingSettings = true;
-    try {
-        if (CONFIG.mcpHttpPort <= 0)
-            return;
-        const allSettings = await readAllKeeperSettings();
-        if (allSettings === null) {
-            log("WARN", "Keeper settings unavailable — preserving existing keepers.");
-            return;
-        }
-        const desiredThreadIds = new Set(allSettings.map(s => s.threadId));
-        // Stop keepers for threads that are no longer configured
-        for (const [tid, entry] of keepers) {
-            if (!desiredThreadIds.has(tid)) {
-                log("INFO", `Keep-alive disabled for thread ${tid} — stopping keeper.`);
-                await entry.handle.stop();
-                keepers.delete(tid);
-            }
-        }
-        // Start or restart keepers
-        for (const settings of allSettings) {
-            const existing = keepers.get(settings.threadId);
-            // Restart if settings changed
-            if (existing && keeperSettingsChanged(existing.settings, settings)) {
-                log("INFO", `Keep-alive settings changed for thread ${settings.threadId} — restarting keeper.`);
-                await existing.handle.stop();
-                keepers.delete(settings.threadId);
-            }
-            // Start if not running
-            if (!keepers.has(settings.threadId)) {
-                try {
-                    const handle = await startClaudeKeeper({
-                        threadId: settings.threadId,
-                        sessionName: settings.sessionName,
-                        client: settings.client,
-                        mcpHttpPort: CONFIG.mcpHttpPort,
-                        mcpHttpSecret: CONFIG.mcpHttpSecret,
-                        workingDirectory: settings.workingDirectory,
-                        maxRetries: settings.maxRetries,
-                        cooldownMs: settings.cooldownMs,
-                        onDeath: (tid, name) => {
-                            void notifyOperator(`💀 <b>${name}</b> session died — restarting…`, tid);
-                        },
-                    });
-                    keepers.set(settings.threadId, { handle, settings });
-                }
-                catch (err) {
-                    log("ERROR", `Failed to start keeper for thread ${settings.threadId}: ${errorMessage(err)}`);
-                }
-            }
-        }
-    }
-    finally {
-        applyingSettings = false;
-    }
-}
-function startKeeperPoller() {
-    keeperPollerHandle = setInterval(() => {
-        void applyKeeperSettings().catch((err) => log("ERROR", `Keeper settings poll failed: ${err}`));
-    }, KEEPER_SETTINGS_POLL_MS);
-}
-// Main loop -------------------------------------------------------------------
-async function runLoop() {
-    log("INFO", `Watcher starting in ${CONFIG.mode} mode.`);
-    ensureDir();
-    // Clear stale maintenance flag left by a previous crash/update cycle.
-    // If the flag exists on watcher startup, the old update is done (or crashed).
-    if (flagExists()) {
-        log("WARN", "Stale maintenance.flag found on startup \u2014 removing.");
-        removeMaintenanceFlag();
-    }
-    const pid = readPid();
-    if (!pid || !alive(pid)) {
-        // Always ensure a fresh server on watcher startup — the old server
-        // may have stale code from a previous watcher's update cycle.
-        await stopMcpServer(); // port-based fallback kills orphan processes
-        await cleanAgentPidFiles(); // remove stale PID files
-        startMcpServer();
-    }
-    void applyKeeperSettings().catch((err) => log("ERROR", `Keeper failed to start: ${err}`));
-    // The first applyKeeperSettings call almost always fails because the MCP server
-    // hasn't finished booting yet (takes 10-60s). Retry after 30s to cover the gap
-    // before the 2-minute poller kicks in.
-    setTimeout(() => {
-        void applyKeeperSettings().catch((err) => log("ERROR", `Keeper retry failed: ${err}`));
-    }, 30_000);
-    startKeeperPoller();
-    if (CONFIG.mode === "production") {
-        while (true) {
-            const ms = msUntilHour(CONFIG.pollAtHour);
-            log("INFO", `Next check in ${Math.round(ms / 60_000)}m (at ${CONFIG.pollAtHour}:00).`);
-            await sleep(ms);
-            try {
-                await checkAndUpdate();
-            }
-            catch (err) {
-                log("ERROR", err);
-                removeMaintenanceFlag();
-            }
-        }
-    }
-    else {
-        while (true) {
-            try {
-                await killStale();
-                await checkAndUpdate();
-            }
-            catch (err) {
-                log("ERROR", err);
-                removeMaintenanceFlag();
-            }
-            await sleep(CONFIG.pollIntervalSeconds * 1000);
-        }
-    }
-}
-// MCP server (await_server_ready) — in-process HTTP ---------------------------
-function createWatcherMcp() {
-    const srv = new Server({ name: "sensorium-watcher", version: "1.0.0" }, { capabilities: { tools: {}, logging: {} } });
-    srv.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: [{
-                name: "await_server_ready",
-                description: "Blocks until sensorium finishes updating (maintenance.flag removed) or 120s timeout. Safe to call multiple times — returns immediately if no update in progress.",
-                inputSchema: { type: "object", properties: {
-                        threadId: { type: "number", description: "Telegram thread ID for reconnecting via start_session." },
-                    } },
-            }] }));
-    srv.setRequestHandler(CallToolRequestSchema, async (req) => {
-        if (req.params.name !== "await_server_ready")
-            return { content: [{ type: "text", text: `Unknown tool: ${req.params.name}` }], isError: true };
-        const tid = req.params.arguments?.threadId ?? 0;
-        const lbl = tid ? `threadId=${tid}` : `threadId=<your thread>`;
-        if (!flagExists()) {
-            return { content: [{ type: "text", text: `Server ready. Call start_session with ${lbl}.` }] };
-        }
-        // Non-blocking: return immediately with retry instruction
-        return { content: [{ type: "text", text: `Update in progress. Use Desktop Commander to run: Start-Sleep -Seconds 30 — then call await_server_ready again with ${lbl}. Repeat until ready.` }] };
-    });
-    return srv;
-}
-function parseBody(req) {
-    const MAX_BODY = 1_048_576; // 1 MB
-    return new Promise((resolve, reject) => {
-        const chunks = [];
-        let size = 0;
-        req.on("data", (c) => {
-            size += c.length;
-            if (size > MAX_BODY) {
-                req.destroy(new Error("Request body exceeds 1 MB limit"));
-                return;
-            }
-            chunks.push(c);
-        });
-        req.on("end", () => { try {
-            resolve(JSON.parse(Buffer.concat(chunks).toString()));
-        }
-        catch (e) {
-            reject(e);
-        } });
-        req.on("error", reject);
-    });
-}
-function startHttpMcp(port) {
-    const transports = new Map();
-    const sessionCreated = new Map();
-    // Session TTL: 24 hours.  Ghost threads establish their watcher session at
-    // startup but may not need await_server_ready for hours.  The old 600 s
-    // timeout caused sessions to expire before the first update arrived,
-    // making await_server_ready fail with "Bad Request".
-    const SESSION_TTL_MS = 86_400_000;
-    sessionSweeperHandle = setInterval(() => {
-        for (const [sid, ts] of sessionCreated) {
-            if (Date.now() - ts > SESSION_TTL_MS) {
-                transports.get(sid)?.close?.();
-                transports.delete(sid);
-                sessionCreated.delete(sid);
-            }
-        }
-    }, 60_000);
-    httpSrv = createServer(async (req, res) => {
-        // CORS: restrict to localhost origins (match http-server.ts pattern)
-        const origin = req.headers.origin ?? "";
-        const allowedOrigin = origin.match(/^https?:\/\/(localhost|127\.0\.0\.1)(:\d+)?$/) ? origin : "";
-        res.setHeader("Access-Control-Allow-Origin", allowedOrigin);
-        res.setHeader("Access-Control-Allow-Methods", "GET, POST, DELETE, OPTIONS");
-        res.setHeader("Access-Control-Allow-Headers", "Content-Type, mcp-session-id, Authorization");
-        res.setHeader("Access-Control-Expose-Headers", "mcp-session-id");
-        if (req.method === "OPTIONS") {
-            res.writeHead(204);
-            res.end();
-            return;
-        }
-        if (req.url !== "/mcp") {
-            res.writeHead(404);
-            res.end("Not Found");
-            return;
-        }
-        const sid = req.headers["mcp-session-id"];
-        try {
-            if (req.method === "POST") {
-                const body = await parseBody(req);
-                const existing = sid ? transports.get(sid) : undefined;
-                if (existing) {
-                    await existing.handleRequest(req, res, body);
-                    return;
-                }
-                // If the client sent a session ID we don't recognise (expired /
-                // watcher restarted), return 404 per the MCP Streamable HTTP spec
-                // so the client re-initialises instead of giving up.
-                if (sid && !existing && !isInitializeRequest(body)) {
-                    log("WARN", `Unknown session ${sid} — returning 404 to trigger re-init`);
-                    res.writeHead(404);
-                    res.end(JSON.stringify({ jsonrpc: "2.0", error: { code: -32001, message: "Session not found — please re-initialize" }, id: null }));
-                    return;
-                }
-                if (isInitializeRequest(body)) {
-                    const t = new StreamableHTTPServerTransport({
-                        sessionIdGenerator: () => randomUUID(),
-                        onsessioninitialized: (s) => { transports.set(s, t); sessionCreated.set(s, Date.now()); },
-                    });
-                    t.onclose = () => { const s = t.sessionId; if (s) {
-                        transports.delete(s);
-                        sessionCreated.delete(s);
-                    } };
-                    await (createWatcherMcp()).connect(t);
-                    await t.handleRequest(req, res, body);
-                    return;
-                }
-                res.writeHead(400);
-                res.end(JSON.stringify({ jsonrpc: "2.0", error: { code: -32000, message: "Bad Request: expected initialize" }, id: null }));
-                return;
-            }
-            if (req.method === "GET" || req.method === "DELETE") {
-                const t = sid ? transports.get(sid) : undefined;
-                if (t) {
-                    await t.handleRequest(req, res);
-                }
-                else {
-                    res.writeHead(404);
-                    res.end("Session not found");
-                }
-                return;
-            }
-            res.writeHead(405);
-            res.end("Method Not Allowed");
-        }
-        catch (err) {
-            log("ERROR", `HTTP handler error: ${err}`);
-            if (!res.headersSent) {
-                res.writeHead(500);
-                res.end(JSON.stringify({ jsonrpc: "2.0", error: { code: -32603, message: "Internal error" }, id: null }));
-            }
-        }
-    });
-    // Disable Node.js HTTP server timeouts — await_server_ready can block
-    // up to 600 s on a single SSE response.  The defaults (requestTimeout=300 s,
-    // headersTimeout=60 s) would destroy the socket mid-wait, silently
-    // dropping the tool result that eventually flows through the SSE stream.
-    httpSrv.requestTimeout = 0;
-    httpSrv.headersTimeout = 0;
-    httpSrv.timeout = 0;
-    httpSrv.listen(port, "127.0.0.1", () => log("INFO", `Watcher MCP on http://127.0.0.1:${port}/mcp`));
-}
-// Lockfile — prevent two watcher instances --------------------------------------
-let lockFd = null;
-function acquireLock() {
-    try {
-        ensureDir();
-        lockFd = openSync(P.lock, "wx");
-        writeFileSync(lockFd, String(process.pid));
-        return true;
-    }
-    catch {
-        // Check if the existing lock holder is still alive
-        const raw = safeRead(P.lock);
-        if (raw) {
-            const pid = parseInt(raw, 10);
-            if (!Number.isNaN(pid) && alive(pid)) {
-                log("ERROR", `Another watcher is already running (PID ${pid}). Exiting.`);
-                return false;
-            }
-        }
-        // Stale lock — reclaim
-        try {
-            unlinkSync(P.lock);
-        }
-        catch { /**/ }
-        try {
-            lockFd = openSync(P.lock, "wx");
-            writeFileSync(lockFd, String(process.pid));
-            log("WARN", "Reclaimed stale watcher lockfile.");
-            return true;
-        }
-        catch {
-            log("ERROR", "Failed to acquire watcher lockfile.");
-            return false;
-        }
-    }
-}
-function releaseLock() {
-    if (lockFd !== null) {
-        try {
-            closeSync(lockFd);
-        }
-        catch { /**/ }
-        lockFd = null;
-    }
-    try {
-        if (existsSync(P.lock))
-            unlinkSync(P.lock);
-    }
-    catch { /**/ }
-}
-// Signal handling & entry point -----------------------------------------------
-export async function startWatcherService() {
-    if (!acquireLock()) {
-        process.exit(1);
-        return;
-    }
-    // Periodic worker cleanup — every 5 minutes, clean expired workers that outlived their TTL
-    workerCleanupHandle = setInterval(() => {
-        const chatId = process.env.TELEGRAM_CHAT_ID || "";
-        if (!chatId)
-            return;
-        void (async () => {
-            try {
-                const db = initMemoryDb();
-                const token = process.env.TELEGRAM_TOKEN || "";
-                const { resolveTelegramTopicId } = await import("./data/memory/thread-registry.js");
-                const telegram = {
-                    async deleteForumTopic(cId, threadId) {
-                        if (!token)
-                            return;
-                        const topicId = resolveTelegramTopicId(db, threadId);
-                        await fetch(`https://api.telegram.org/bot${token}/deleteForumTopic`, {
-                            method: "POST",
-                            headers: { "Content-Type": "application/json" },
-                            body: JSON.stringify({ chat_id: cId, message_thread_id: topicId }),
-                            signal: AbortSignal.timeout(10_000),
-                        });
-                    },
-                };
-                const result = await cleanupExpiredWorkers(db, telegram, chatId);
-                if (result.cleaned > 0)
-                    log("INFO", `[worker-cleanup] Cleaned ${result.cleaned} expired worker threads`);
-            }
-            catch (err) {
-                log("WARN", `[worker-cleanup] ${errorMessage(err)}`);
-            }
-        })();
-    }, 5 * 60 * 1000);
-    const shutdown = async () => {
-        if (keeperPollerHandle)
-            clearInterval(keeperPollerHandle);
-        if (sessionSweeperHandle)
-            clearInterval(sessionSweeperHandle);
-        if (workerCleanupHandle)
-            clearInterval(workerCleanupHandle);
-        log("INFO", "Shutting down watcher...");
-        // Timeout guard: don't hang on stuck keepers or server
-        await Promise.race([
-            Promise.allSettled([...keepers].map(([, e]) => e.handle.stop())),
-            sleep(10_000),
-        ]);
-        keepers.clear();
-        await Promise.race([stopMcpServer(), sleep(10_000)]);
-        httpSrv?.close();
-        releaseLock();
-        process.exit(process.exitCode ?? 0);
-    };
-    process.on("SIGINT", () => void shutdown());
-    process.on("SIGTERM", () => void shutdown());
-    startHttpMcp(CONFIG.httpPort);
-    await runLoop();
-}
-//# sourceMappingURL=watcher-service.js.map