@prom.codes/memory-mcp 0.11.0 → 0.11.2

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";
@@ -1020,6 +1076,7 @@ var DEFAULT_BATCH4 = 100;
 var DEFAULT_BATCH_CHARS2 = 4e5;
 var DEFAULT_RETRIES4 = 4;
 var DEFAULT_BACKOFF4 = 250;
+var DEFAULT_TIMEOUT_MS2 = 15e3;
 function sleep4(ms, signal) {
   return new Promise((resolve3, reject) => {
     if (signal?.aborted === true) {
@@ -1052,6 +1109,7 @@ var PrometheusRerankProvider = class {
   #maxBatchChars;
   #maxRetries;
   #retryBaseMs;
+  #timeoutMs;
   #fetch;
   #creditsUsed = 0;
   constructor(opts) {
@@ -1068,8 +1126,12 @@ var PrometheusRerankProvider = class {
     this.#url = `${(opts.baseUrl ?? DEFAULT_BASE2).replace(/\/+$/, "")}/rerank`;
     this.#batchSize = opts.batchSize ?? DEFAULT_BATCH4;
     this.#maxBatchChars = opts.maxBatchChars ?? DEFAULT_BATCH_CHARS2;
+    if (opts.timeoutMs !== void 0 && (!Number.isInteger(opts.timeoutMs) || opts.timeoutMs < 0)) {
+      throw new Error(`PrometheusRerankProvider: timeoutMs must be a non-negative integer (0 disables), got ${opts.timeoutMs}`);
+    }
     this.#maxRetries = opts.maxRetries ?? DEFAULT_RETRIES4;
     this.#retryBaseMs = opts.retryBaseMs ?? DEFAULT_BACKOFF4;
+    this.#timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS2;
     this.#fetch = opts.fetch ?? fetch;
   }
   /** Cumulative credits charged across all rerank calls of this instance. */
@@ -1128,8 +1190,6 @@ var PrometheusRerankProvider = class {
       },
       body: JSON.stringify({ query, documents: batch.map((c) => c.text) })
     };
-    if (signal !== void 0)
-      init.signal = signal;
     const payload = await this.#requestJson(init, signal);
     if (payload?.ok !== true || !Array.isArray(payload.results)) {
       throw nonRetryable4("prometheus-rerank: malformed rerank response");
@@ -1161,8 +1221,25 @@ var PrometheusRerankProvider = class {
     let attempt = 0;
     let lastError = null;
     while (attempt <= this.#maxRetries) {
+      const controller = new AbortController();
+      let timedOut = false;
+      let timer;
+      if (this.#timeoutMs > 0) {
+        timer = setTimeout(() => {
+          timedOut = true;
+          controller.abort();
+        }, this.#timeoutMs);
+        timer.unref?.();
+      }
+      const onParentAbort = () => controller.abort();
+      if (signal !== void 0) {
+        if (signal.aborted)
+          controller.abort();
+        else
+          signal.addEventListener("abort", onParentAbort, { once: true });
+      }
       try {
-        const res = await this.#fetch(this.#url, init);
+        const res = await this.#fetch(this.#url, { ...init, signal: controller.signal });
         if (res.status >= 500 && res.status < 600) {
           lastError = new Error(`prometheus-rerank: HTTP ${res.status}`);
           attempt += 1;
@@ -1178,15 +1255,21 @@ var PrometheusRerankProvider = class {
         }
         return await res.json();
       } catch (err) {
-        if (err?.name === "AbortError")
+        if (err?.name === "AbortError" && !timedOut)
           throw err;
         if (err?.nonRetryable === true)
           throw err;
+        const retryErr = timedOut ? new Error(`prometheus-rerank: request timed out after ${this.#timeoutMs}ms`) : err;
         if (attempt >= this.#maxRetries)
-          throw err;
-        lastError = err;
+          throw retryErr;
+        lastError = retryErr;
         attempt += 1;
         await sleep4(this.#retryBaseMs * 2 ** (attempt - 1), signal);
+      } finally {
+        if (timer !== void 0)
+          clearTimeout(timer);
+        if (signal !== void 0)
+          signal.removeEventListener("abort", onParentAbort);
       }
     }
     throw lastError instanceof Error ? lastError : new Error(`prometheus-rerank: exhausted ${this.#maxRetries} retries`);
@@ -3315,7 +3398,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.2", { 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 +3434,7 @@ ${f.value}`);
 // dist/server.js
 var SERVER_IDENTITY = {
   name: "prometheus-memory-mcp",
-  version: "0.11.0",
+  version: "0.11.2",
   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 +3468,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 +3476,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 +3491,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 +3537,7 @@ async function main() {
   if (eagerVia !== null) {
     boot(void 0, eagerVia);
     await server.connect(transport);
+    armIdleWatch();
     return;
   }
   let booted = false;
@@ -3463,6 +3561,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.2",
   "description": "prom.codes Memory — persistent, local-first agent memory as an MCP server.",
   "type": "module",
   "bin": {