@prom.codes/memory-mcp 0.11.0 → 0.11.1

package/dist/bin.js

@@ -89,6 +89,9 @@ function isNewerVersion(latest, current) {
     return true;
   return false;
 }
+function cachedLatestIsStale(cachedLatest, minVersion) {
+  return minVersion !== void 0 && cachedLatest !== null && isNewerVersion(minVersion, cachedLatest);
+}
 function cachePath(dir, name) {
   const safe = name.replace(/[^a-zA-Z0-9._-]+/g, "_");
   return join(dir, `.update-check-${safe}.json`);
@@ -175,7 +178,7 @@ async function checkForUpdate(options) {
   const now = Date.now();
   if (!force) {
     const cached = await readCache(file);
-    if (cached !== null && now - cached.checkedAt < cacheTtlMs) {
+    if (cached !== null && now - cached.checkedAt < cacheTtlMs && !cachedLatestIsStale(cached.latest, version)) {
       const updateAvailable2 = cached.latest !== null && isNewerVersion(cached.latest, version);
       if (updateAvailable2)
         notify(log, name, version, cached.latest);
@@ -202,15 +205,16 @@ async function checkForUpdate(options) {
   return { ...base, latest, checked: true, updateAvailable };
 }
 async function getLatestVersion(name, options = {}) {
-  const { env = process.env, fetch: fetchImpl = globalThis.fetch, cacheDir = join(homedir(), ".prometheus"), cacheTtlMs = DEFAULT_TTL_MS, timeoutMs = DEFAULT_TIMEOUT_MS } = options;
+  const { env = process.env, fetch: fetchImpl = globalThis.fetch, cacheDir = join(homedir(), ".prometheus"), cacheTtlMs = DEFAULT_TTL_MS, timeoutMs = DEFAULT_TIMEOUT_MS, minVersion } = options;
   const file = cachePath(cacheDir, name);
   const cached = await readCache(file);
   const now = Date.now();
-  if (cached !== null && cached.latest !== null && now - cached.checkedAt < cacheTtlMs) {
+  const stale = cachedLatestIsStale(cached?.latest ?? null, minVersion);
+  if (cached !== null && cached.latest !== null && now - cached.checkedAt < cacheTtlMs && !stale) {
     return cached.latest;
   }
   if (OPT_OUT_RE.test(env.PROMETHEUS_NO_UPDATE_CHECK ?? "") || typeof fetchImpl !== "function") {
-    return cached?.latest ?? null;
+    return stale ? null : cached?.latest ?? null;
   }
   const latest = await fetchLatest(name, fetchImpl, timeoutMs);
   if (latest !== null) {
@@ -218,7 +222,7 @@ async function getLatestVersion(name, options = {}) {
     await writeCache(file, { checkedAt: now, latest });
     return latest;
   }
-  return cached?.latest ?? null;
+  return stale ? null : cached?.latest ?? null;
 }
 function notify(log, name, current, latest) {
   log(`${name}: a newer version (${latest}) is available \u2014 you are on ${current}. npx users get it automatically on the next restart; for a global install run \`npm update -g ${name}\`. (Set PROMETHEUS_NO_UPDATE_CHECK=1 to silence.)
@@ -242,7 +246,8 @@ async function buildUpdateStatus(pkgName, currentVersion, options = {}) {
       ...options.env !== void 0 ? { env: options.env } : {},
       ...options.fetch !== void 0 ? { fetch: options.fetch } : {},
       ...options.cacheDir !== void 0 ? { cacheDir: options.cacheDir } : {},
-      timeoutMs: options.timeoutMs ?? 1500
+      timeoutMs: options.timeoutMs ?? 1500,
+      minVersion: currentVersion
     });
   } catch {
     latest = null;
@@ -338,6 +343,57 @@ function startHeartbeat(options) {
   };
 }
 
+// ../shared/dist/idle-watchdog.js
+var DEFAULT_IDLE_EXIT_MS = 30 * 6e4;
+var IDLE_CHECK_INTERVAL_MS = 6e4;
+var IDLE_EXIT_ENV = "PROMETHEUS_IDLE_EXIT_MS";
+function parseIdleExitMs(env) {
+  const raw = (env[IDLE_EXIT_ENV] ?? "").trim();
+  if (raw === "")
+    return void 0;
+  const n = Number(raw);
+  return Number.isFinite(n) && n >= 0 ? n : void 0;
+}
+function createIdleWatchdog(options) {
+  const env = options.env ?? process.env;
+  const idleMs = options.idleMs ?? parseIdleExitMs(env) ?? DEFAULT_IDLE_EXIT_MS;
+  const now = options.now ?? Date.now;
+  const checkIntervalMs = options.checkIntervalMs ?? Math.max(1e3, Math.min(IDLE_CHECK_INTERVAL_MS, idleMs));
+  if (!(idleMs > 0)) {
+    return { touch() {
+    }, stop() {
+    }, idleMs: 0 };
+  }
+  let lastActivity = now();
+  let stopped = false;
+  let fired = false;
+  const timer = setInterval(() => {
+    if (stopped || fired)
+      return;
+    const idleFor = now() - lastActivity;
+    if (idleFor >= idleMs) {
+      fired = true;
+      clearInterval(timer);
+      options.onIdle(`idle for ${Math.round(idleFor / 1e3)}s with no client activity (set ${IDLE_EXIT_ENV}=0 to disable)`);
+    }
+  }, checkIntervalMs);
+  timer.unref?.();
+  return {
+    idleMs,
+    touch() {
+      if (stopped)
+        return;
+      lastActivity = now();
+    },
+    stop() {
+      if (stopped)
+        return;
+      stopped = true;
+      clearInterval(timer);
+    }
+  };
+}
+
 // dist/composition.js
 import { createHash } from "node:crypto";
 import { homedir as homedir4 } from "node:os";
@@ -3315,7 +3371,7 @@ ${f.value}`);
         embeddingsError = err instanceof Error ? err.message : String(err);
       }
     }
-    const update = await buildUpdateStatus("@prom.codes/memory-mcp", "0.11.0", { isDevBuild: false });
+    const update = await buildUpdateStatus("@prom.codes/memory-mcp", "0.11.1", { isDevBuild: false });
     const summary = deps.rootIsHomeOrFsRoot ? `Memory at ${dbPath}: ${stats.total} records, but the workspace resolved to ${workspaceRoot} (home/root) \u2014 open a project folder so memories scope and mirror correctly.` : `Memory at ${dbPath}: ${stats.total} records for project "${projectName}".${update.updateAvailable === true ? ` Update available: ${update.current} \u2192 ${update.latest} (ask me to run update via the context server's update_servers tool).` : ""}`;
     return textResult({
       installed: true,
@@ -3351,7 +3407,7 @@ ${f.value}`);
 // dist/server.js
 var SERVER_IDENTITY = {
   name: "prometheus-memory-mcp",
-  version: "0.11.0",
+  version: "0.11.1",
   title: "prom.codes Memory"
 };
 var SERVER_INSTRUCTIONS = "Persistent agent memory for this workspace \u2014 USE IT PROACTIVELY; the user will not tell you to. Protocol:\n1. ONE-TIME: if this workspace has no Prometheus memory rule yet, call memory_setup now (idempotent) so the protocol is installed into the runtime rule files and survives future sessions. (The server also auto-installs it on startup when a project rule file already exists \u2014 memory_setup covers the rest.)\n2. SESSION START: before any non-trivial task, call memory_read to recall facts, decisions and procedures from earlier sessions.\n3. DURING WORK: when the user states a durable preference, decision, correction or project fact, store it with memory_write (semantic for facts, procedural for how-tos) \u2014 without being asked.\n4. LOOK-UP: use memory_search for keyword recall when memory_read is not specific enough.\n5. SESSION END: consolidate what was learned with memory_capture.\nCall memory_status anytime to check what is stored and whether the rule is installed. Never store secrets, API keys or credentials \u2014 such writes are rejected.";
@@ -3385,6 +3441,7 @@ async function main() {
   registerTools(server, () => composedReady, {
     onToolCall: (tool) => heartbeat.update({ lastTool: tool, lastToolCallAt: Date.now() })
   });
+  let watchdog = null;
   let shuttingDown = false;
   const shutdown = async (reason) => {
     if (shuttingDown)
@@ -3392,6 +3449,7 @@ async function main() {
     shuttingDown = true;
     process.stderr.write(`prometheus-memory-mcp: ${reason}, shutting down
 `);
+    watchdog?.stop();
     heartbeat.stop();
     try {
       await server.close();
@@ -3406,6 +3464,18 @@ async function main() {
   process.stdin.once("end", () => void shutdown("stdin closed (client exited)"));
   process.stdin.once("close", () => void shutdown("stdin closed (client exited)"));
   server.server.onclose = () => void shutdown("transport closed (client exited)");
+  watchdog = createIdleWatchdog({ onIdle: (reason) => void shutdown(reason), env });
+  if (watchdog.idleMs > 0) {
+    process.stderr.write(`prometheus-memory-mcp: idle self-exit armed (${Math.round(watchdog.idleMs / 6e4)} min of no client activity)
+`);
+  }
+  const armIdleWatch = () => {
+    const prev = transport.onmessage?.bind(transport);
+    transport.onmessage = ((...args) => {
+      watchdog?.touch();
+      prev?.(...args);
+    });
+  };
   const boot = (override, via) => {
     composed = composeFromEnv({
       env,
@@ -3440,6 +3510,7 @@ async function main() {
   if (eagerVia !== null) {
     boot(void 0, eagerVia);
     await server.connect(transport);
+    armIdleWatch();
     return;
   }
   let booted = false;
@@ -3463,6 +3534,7 @@ async function main() {
     void resolveAndBoot();
   };
   await server.connect(transport);
+  armIdleWatch();
   const t = setTimeout(() => void resolveAndBoot(), 5e3);
   t.unref?.();
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prom.codes/memory-mcp",
-  "version": "0.11.0",
+  "version": "0.11.1",
   "description": "prom.codes Memory — persistent, local-first agent memory as an MCP server.",
   "type": "module",
   "bin": {