@llmnesia/mcp 0.1.12 → 0.1.14

package/README.md

@@ -48,19 +48,38 @@ The installer:
 1. sets up the native host that bridges the browser extension to your local
    corpus,
 2. copies the server into `~/.llmnesia/bin` so it has a permanent home,
-3. sets up the supported desktop AI apps (Claude Code, Claude Desktop, Cursor,
+3. sets up the supported desktop AI apps (Claude Code, Cursor,
    and Codex/ChatGPT), and
 4. registers that copy using the client's own CLI where available, or with an
    automatic backup before editing its documented user config. It prepares all
    of those standard config paths, so an app installed later does not require
    running setup again.
 
-On Windows, Claude Desktop uses its supported packaged-extension flow instead
-of the legacy JSON config. If Claude is installed, its normal LLMnesia install
-window opens during setup; click **Install** once. Claude can run that extension
-with its built-in Node.js, while the system Node installation continues to run
-the browser helper and other desktop AI integrations. If Claude is installed
-later, run the same LLMnesia setup command once more.
+Claude Desktop on Windows does not provide a supported API for third-party
+installers to add a local desktop extension. LLMnesia therefore leaves any
+existing Claude configuration untouched rather than claiming that Claude has
+been connected.
+
+### Claude Desktop on Windows (current one-time manual step)
+
+Until LLMnesia is available in Claude's extension directory, Claude Desktop on
+Windows has one extra, manual step. First run `install` above so the local
+browser bridge and corpus exist. Then download the official LLMnesia
+`llmnesia.mcpb` desktop-extension file from LLMnesia and use Claude Desktop's
+**Settings → Extensions → Install extension** flow to install it. Fully quit
+and reopen Claude Desktop afterwards.
+
+This is deliberately separate from the npm command: Claude does not provide a
+supported Windows API for another installer to silently add an `.mcpb`
+extension. The command therefore never edits Claude's internal extension state
+or reports a false success. The packaged extension itself is read-only: it can
+search, list, and read the local corpus but cannot modify it.
+
+The future Claude Directory listing is a convenience distribution route, not a
+dependency for the general LLMnesia release. It will replace this one manual
+Claude step with Claude's own in-app install button if Anthropic selects the
+extension. See [`docs/CLAUDE_DESKTOP_RELEASE_PLAN.md`](../docs/CLAUDE_DESKTOP_RELEASE_PLAN.md)
+for the release and directory-submission plan.
 
 The `install` command is the approval to perform those setup steps. It does not
 interrupt setup with a separate prompt for every detected app, and it never
@@ -128,7 +147,7 @@ received data — check it before concluding a chat does not exist.
 | Client | How `install` wires it |
 | --- | --- |
 | Claude Code | Runs `claude mcp add --scope user` with the absolute Node and installed runtime paths when available. Otherwise it writes the documented user-scope `~/.claude.json` entry, so Windows users do not need the `claude` command on PATH. |
-| Claude Desktop | Windows opens Claude's regular packaged-extension installer and removes obsolete LLMnesia JSON entries. macOS keeps the working local JSON registration. |
+| Claude Desktop | macOS uses the working local JSON registration. On Windows, run `install` for browser sync, then install the official `llmnesia.mcpb` once in Claude Desktop; Claude exposes no supported external installation API for custom desktop extensions. |
 | Cursor | Edits `~/.cursor/mcp.json`, preparing it in advance if Cursor is installed later. |
 | Codex / ChatGPT desktop | Runs `codex mcp add` with the absolute runtime paths when available. If the bundled CLI is unavailable, the installer safely edits `~/.codex/config.toml` itself and backs up existing settings first, including preparing it for a later installation. Read-only LLMnesia tools are configured to run without repeated approval prompts; writes still ask. |
 | Others (Windsurf, Zed, LM Studio, …) | Prints the generic stdio block for you to paste. |
@@ -185,6 +204,23 @@ llmnesia-mcp --version     # print the installed version
 
 Questions and bug reports: [hello@llmnesia.com](mailto:hello@llmnesia.com).
 
+## Privacy Policy
+
+The MCP server reads and writes only the LLMnesia corpus stored on the user's
+own computer. It does not upload conversation content, titles, URLs, prompts,
+responses, or search queries to LLMnesia or to any third party, and it makes no
+analytics or advertising requests of its own.
+
+The browser extension separately sends limited, non-content product analytics
+to PostHog. Conversation data and MCP searches are excluded. The complete
+policy explains collection, local storage, third-party processing, retention,
+deletion, and contact details:
+[LLMnesia Privacy Policy](https://www.llmnesia.com/privacy-policy).
+
+The local MCP corpus remains on the device until the user deletes it. Running
+`uninstall` deliberately leaves that corpus intact so uninstalling the helper
+cannot accidentally destroy the user's history.
+
 ## License
 
 MIT — see [LICENSE](./LICENSE).

package/dist/{chunk-3JQ7CGCP.js → chunk-JS2GFGNW.js}

@@ -1,6 +1,9 @@
 #!/usr/bin/env node
 import { createRequire as __llmnesiaCreateRequire } from "node:module";
 const require = __llmnesiaCreateRequire(import.meta.url);
+import {
+  VERSION
+} from "./chunk-QGVH3T5W.js";
 
 // src/config.ts
 import { readFileSync } from "fs";
@@ -102,6 +105,7 @@ function canonicalConversationDoc(c) {
     createdAt: c.createdAt,
     contentUpdatedAt: c.contentUpdatedAt,
     indexedAt: c.indexedAt,
+    corpusChangedAt: c.corpusChangedAt,
     updatedAt: c.updatedAt,
     lastSeenAt: c.lastSeenAt,
     messageCount: c.messageCount,
@@ -207,10 +211,10 @@ var Corpus = class {
 `);
   }
   /**
-   * Insert or replace a conversation, keyed on docId with last-write-wins by
-   * `conversation.updatedAt`. A stale write (older updatedAt than what's on
-   * disk) is a no-op. Re-writing identical content produces byte-identical
-   * output, so replaying a delta is safe.
+   * Insert or replace a conversation, keyed on docId. New bridge records use
+   * the local `corpusChangedAt` mutation clock; older records fall back to the
+   * source `updatedAt`. If mutation clocks tie, source freshness breaks the
+   * tie. Re-writing identical content remains a byte-identical no-op.
    */
   async upsert(record) {
     return this.enqueueWrite(async () => {
@@ -219,9 +223,11 @@ var Corpus = class {
       const file = this.paths.conversationFile(conversation.platform, conversation.docId);
       const existing = await readJsonIfExists(file);
       if (existing) {
+        const existingChangedAt = existing.conversation.corpusChangedAt ?? existing.conversation.updatedAt ?? 0;
+        const incomingChangedAt = conversation.corpusChangedAt ?? conversation.updatedAt ?? 0;
         const existingUpdatedAt = existing.conversation.updatedAt ?? 0;
         const incomingUpdatedAt = conversation.updatedAt ?? 0;
-        if (incomingUpdatedAt < existingUpdatedAt) {
+        if (incomingChangedAt < existingChangedAt || incomingChangedAt === existingChangedAt && incomingUpdatedAt < existingUpdatedAt) {
           return { docId: conversation.docId, outcome: "skipped" };
         }
       }
@@ -841,6 +847,295 @@ function normalizeMatchRole(role) {
   return role === "assistant" || role === "user" || role === "system" ? role : "unknown";
 }
 
+// src/runtimeInstall.ts
+import { cp, mkdir, readdir, rename, rm, writeFile } from "fs/promises";
+import { existsSync } from "fs";
+import { homedir as homedir2 } from "os";
+import { dirname as dirname2, join as join5 } from "path";
+import { fileURLToPath } from "url";
+function defaultSourceDir() {
+  return dirname2(fileURLToPath(import.meta.url));
+}
+function runtimeBinDir(home = homedir2()) {
+  return join5(home, ".llmnesia", "bin");
+}
+async function installRuntime(options = {}) {
+  const home = options.home ?? homedir2();
+  const sourceDir = options.sourceDir ?? defaultSourceDir();
+  const nodePath = options.nodePath ?? process.execPath;
+  const binDir = runtimeBinDir(home);
+  const sourceEntry = join5(sourceDir, "cli.js");
+  if (!existsSync(sourceEntry)) {
+    throw new Error(
+      `Cannot locate the built runtime: no cli.js in ${sourceDir}. Run this from an installed package (npx -y @llmnesia/mcp@latest install) or build first (npm run build).`
+    );
+  }
+  const parentDir = dirname2(binDir);
+  const nonce = `${process.pid}-${Date.now()}`;
+  const stagingDir = join5(parentDir, `.bin-install-${nonce}`);
+  const backupDir = join5(parentDir, `.bin-backup-${nonce}`);
+  await mkdir(parentDir, { recursive: true });
+  await rm(stagingDir, { recursive: true, force: true });
+  await rm(backupDir, { recursive: true, force: true });
+  await mkdir(stagingDir, { recursive: true });
+  try {
+    for (const name of await readdir(sourceDir)) {
+      await cp(join5(sourceDir, name), join5(stagingDir, name), { recursive: true });
+    }
+    await writeFile(
+      join5(stagingDir, "package.json"),
+      `${JSON.stringify(
+        {
+          name: "llmnesia-mcp-runtime",
+          private: true,
+          type: "module",
+          // Stamped so the installed build is identifiable without spawning it.
+          // Its absence is how a machine sat on 0.1.3 while npm was ten
+          // releases ahead and nothing, doctor included, could say so.
+          version: options.version ?? VERSION,
+          comment: "Installed copy of @llmnesia/mcp's dist. Managed by the LLMnesia installer; edits are lost on reinstall."
+        },
+        null,
+        2
+      )}
+`,
+      "utf8"
+    );
+    const hadPreviousRuntime = existsSync(binDir);
+    if (hadPreviousRuntime) {
+      await rename(binDir, backupDir);
+    }
+    try {
+      await rename(stagingDir, binDir);
+    } catch (err) {
+      if (hadPreviousRuntime && !existsSync(binDir) && existsSync(backupDir)) {
+        await rename(backupDir, binDir);
+      }
+      throw err;
+    }
+    await rm(backupDir, { recursive: true, force: true });
+  } finally {
+    await rm(stagingDir, { recursive: true, force: true });
+  }
+  const entry = join5(binDir, "cli.js");
+  return {
+    binDir,
+    entry,
+    serve: { command: nodePath, args: [entry, "serve"] },
+    sourceDir,
+    nodePath
+  };
+}
+async function uninstallRuntime(home = homedir2()) {
+  const binDir = runtimeBinDir(home);
+  if (!existsSync(binDir)) {
+    return null;
+  }
+  await rm(binDir, { recursive: true, force: true });
+  return binDir;
+}
+
+// src/selfUpdate.ts
+import { spawn } from "child_process";
+import { mkdtemp, readFile, rm as rm2, writeFile as writeFile2 } from "fs/promises";
+import { dirname as dirname3, join as join6 } from "path";
+import { homedir as homedir3, tmpdir } from "os";
+import { fileURLToPath as fileURLToPath2 } from "url";
+var PACKAGE_NAME = "@llmnesia/mcp";
+var REGISTRY_LATEST_URL = "https://registry.npmjs.org/@llmnesia%2Fmcp/latest";
+var UPDATE_CHECK_INTERVAL_MS = 24 * 60 * 60 * 1e3;
+var REGISTRY_TIMEOUT_MS = 5e3;
+var INSTALL_TIMEOUT_MS = 12e4;
+var UPDATE_CHECK_DELAY_MS = 3e4;
+function stateFile(home) {
+  return join6(home, ".llmnesia", "update-state.json");
+}
+async function readState(home) {
+  try {
+    const parsed = JSON.parse(await readFile(stateFile(home), "utf8"));
+    return typeof parsed === "object" && parsed !== null ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+async function writeState(home, state) {
+  try {
+    await writeFile2(stateFile(home), `${JSON.stringify(state, null, 2)}
+`, "utf8");
+  } catch {
+  }
+}
+function compareVersions(a, b) {
+  const parse = (v) => {
+    const match = /^(\d+)\.(\d+)\.(\d+)/.exec(v.trim());
+    return match ? [Number(match[1]), Number(match[2]), Number(match[3])] : [];
+  };
+  const left = parse(a);
+  const right = parse(b);
+  if (left.length === 0 || right.length === 0) {
+    return 0;
+  }
+  for (let i = 0; i < 3; i += 1) {
+    if (left[i] !== right[i]) {
+      return left[i] - right[i];
+    }
+  }
+  return 0;
+}
+function isStableRelease(version) {
+  return /^\d+\.\d+\.\d+$/.test(version.trim());
+}
+function isSelfUpdateDisabled(env = process.env) {
+  const raw = env.LLMNESIA_NO_AUTO_UPDATE;
+  return raw === "1" || raw === "true";
+}
+async function fetchLatestFromRegistry() {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), REGISTRY_TIMEOUT_MS);
+  try {
+    const response = await fetch(REGISTRY_LATEST_URL, {
+      signal: controller.signal,
+      headers: { accept: "application/json" }
+    });
+    if (!response.ok) {
+      throw new Error(`registry responded ${response.status}`);
+    }
+    const body = await response.json();
+    if (typeof body.version !== "string") {
+      throw new Error("registry response had no version");
+    }
+    return body.version;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+function npmCommand() {
+  const binDir = dirname3(process.execPath);
+  return process.platform === "win32" ? join6(binDir, "npm.cmd") : join6(binDir, "npm");
+}
+async function npmDownload(version) {
+  const prefix = await mkdtemp(join6(tmpdir(), "llmnesia-update-"));
+  await new Promise((resolve2, reject) => {
+    const child = spawn(
+      npmCommand(),
+      [
+        "install",
+        `${PACKAGE_NAME}@${version}`,
+        "--prefix",
+        prefix,
+        "--no-audit",
+        "--no-fund",
+        "--no-save",
+        "--loglevel",
+        "error"
+      ],
+      { stdio: ["ignore", "ignore", "pipe"], windowsHide: true }
+    );
+    let stderr = "";
+    child.stderr?.on("data", (chunk) => {
+      stderr += String(chunk);
+    });
+    const timer = setTimeout(() => child.kill(), INSTALL_TIMEOUT_MS);
+    child.once("error", (err) => {
+      clearTimeout(timer);
+      reject(err);
+    });
+    child.once("close", (code) => {
+      clearTimeout(timer);
+      if (code === 0) {
+        resolve2();
+      } else {
+        reject(new Error(`npm install exited ${code}${stderr ? `: ${stderr.trim()}` : ""}`));
+      }
+    });
+  });
+  return join6(prefix, "node_modules", PACKAGE_NAME, "dist");
+}
+async function maybeSelfUpdate(options = {}) {
+  const env = options.env ?? process.env;
+  if (isSelfUpdateDisabled(env)) {
+    return { action: "disabled" };
+  }
+  const home = options.home ?? homedir3();
+  const currentVersion = options.currentVersion ?? VERSION;
+  const runningDir = options.runningDir ?? dirname3(fileURLToPath2(import.meta.url));
+  if (runningDir !== runtimeBinDir(home)) {
+    return { action: "not-installed-runtime" };
+  }
+  if (!isStableRelease(currentVersion)) {
+    return { action: "not-a-release-build", currentVersion };
+  }
+  const now = options.now ?? Date.now;
+  const state = await readState(home);
+  if (state.lastCheckedAt !== void 0 && now() - state.lastCheckedAt < UPDATE_CHECK_INTERVAL_MS) {
+    return { action: "throttled" };
+  }
+  let latest;
+  try {
+    latest = await (options.fetchLatestVersion ?? fetchLatestFromRegistry)();
+  } catch (err) {
+    await writeState(home, { ...state, lastCheckedAt: now() });
+    return { action: "check-failed", error: err instanceof Error ? err.message : String(err) };
+  }
+  const checked = { ...state, lastCheckedAt: now(), lastSeenVersion: latest };
+  if (!isStableRelease(latest) || compareVersions(latest, currentVersion) <= 0) {
+    await writeState(home, checked);
+    return { action: "up-to-date", latest };
+  }
+  if (state.lastFailedVersion === latest) {
+    await writeState(home, checked);
+    return { action: "skipped-failed-before", latest };
+  }
+  let sourceDir;
+  try {
+    sourceDir = await (options.downloadPackage ?? npmDownload)(latest);
+    await installRuntime({ home, sourceDir, version: latest });
+    await writeState(home, { ...checked, lastUpdatedTo: latest, lastFailedVersion: void 0 });
+    return { action: "updated", from: currentVersion, to: latest };
+  } catch (err) {
+    await writeState(home, { ...checked, lastFailedVersion: latest });
+    return { action: "update-failed", latest, error: err instanceof Error ? err.message : String(err) };
+  } finally {
+    if (sourceDir) {
+      await rm2(join6(sourceDir, "..", "..", ".."), { recursive: true, force: true }).catch(() => {
+      });
+    }
+  }
+}
+function scheduleSelfUpdate(options = {}) {
+  const { delayMs = UPDATE_CHECK_DELAY_MS, onOutcome, ...rest } = options;
+  const timer = setTimeout(() => {
+    void maybeSelfUpdate(rest).then(
+      (outcome) => onOutcome?.(outcome),
+      () => {
+      }
+    );
+  }, delayMs);
+  timer.unref?.();
+}
+function describeOutcome(outcome) {
+  switch (outcome.action) {
+    case "updated":
+      return `updated ${outcome.from} to ${outcome.to}; it takes effect next launch`;
+    case "update-failed":
+      return `could not install ${outcome.latest}: ${outcome.error}`;
+    case "check-failed":
+      return `could not reach the npm registry: ${outcome.error}`;
+    case "up-to-date":
+      return `already current (latest published is ${outcome.latest})`;
+    case "skipped-failed-before":
+      return `${outcome.latest} failed to install previously; not retrying automatically`;
+    case "throttled":
+      return "checked recently";
+    case "disabled":
+      return "automatic updates are turned off (LLMNESIA_NO_AUTO_UPDATE)";
+    case "not-installed-runtime":
+      return "not running from ~/.llmnesia/bin, so nothing to update";
+    case "not-a-release-build":
+      return `running an unreleased build (${outcome.currentVersion}); leaving the installed runtime alone`;
+  }
+}
+
 export {
   resolveCorpusDir,
   Corpus,
@@ -849,5 +1144,11 @@ export {
   drainInbox,
   SearchIndex,
   openSearchIndex,
-  deleteIndexDb
+  deleteIndexDb,
+  runtimeBinDir,
+  installRuntime,
+  uninstallRuntime,
+  isSelfUpdateDisabled,
+  scheduleSelfUpdate,
+  describeOutcome
 };

package/dist/{chunk-MI5RBP7Y.js → chunk-QGVH3T5W.js}

@@ -38,7 +38,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 
 // src/version.ts
-var VERSION = true ? "0.1.12" : "0.0.0-dev";
+var VERSION = true ? "0.1.14" : "0.0.0-dev";
 
 export {
   __require,

package/dist/{cli-GKHVUCEP.js → cli-I2P4TSZW.js}

@@ -7,15 +7,19 @@ import {
   deleteIndexDb,
   drainInbox,
   ingestFile,
+  installRuntime,
+  isSelfUpdateDisabled,
   openSearchIndex,
-  resolveCorpusDir
-} from "./chunk-3JQ7CGCP.js";
+  resolveCorpusDir,
+  runtimeBinDir,
+  uninstallRuntime
+} from "./chunk-JS2GFGNW.js";
 import {
   VERSION,
   __commonJS,
   __require,
   __toESM
-} from "./chunk-MI5RBP7Y.js";
+} from "./chunk-QGVH3T5W.js";
 
 // ../node_modules/isexe/windows.js
 var require_windows = __commonJS({
@@ -41,15 +45,15 @@ var require_windows = __commonJS({
       }
       return false;
     }
-    function checkStat(stat7, path, options) {
-      if (!stat7.isSymbolicLink() && !stat7.isFile()) {
+    function checkStat(stat6, path, options) {
+      if (!stat6.isSymbolicLink() && !stat6.isFile()) {
         return false;
       }
       return checkPathExt(path, options);
     }
     function isexe(path, options, cb) {
-      fs.stat(path, function(er, stat7) {
-        cb(er, er ? false : checkStat(stat7, path, options));
+      fs.stat(path, function(er, stat6) {
+        cb(er, er ? false : checkStat(stat6, path, options));
       });
     }
     function sync(path, options) {
@@ -66,20 +70,20 @@ var require_mode = __commonJS({
     isexe.sync = sync;
     var fs = __require("fs");
     function isexe(path, options, cb) {
-      fs.stat(path, function(er, stat7) {
-        cb(er, er ? false : checkStat(stat7, options));
+      fs.stat(path, function(er, stat6) {
+        cb(er, er ? false : checkStat(stat6, options));
       });
     }
     function sync(path, options) {
       return checkStat(fs.statSync(path), options);
     }
-    function checkStat(stat7, options) {
-      return stat7.isFile() && checkMode(stat7, options);
+    function checkStat(stat6, options) {
+      return stat6.isFile() && checkMode(stat6, options);
     }
-    function checkMode(stat7, options) {
-      var mod = stat7.mode;
-      var uid = stat7.uid;
-      var gid = stat7.gid;
+    function checkMode(stat6, options) {
+      var mod = stat6.mode;
+      var uid = stat6.uid;
+      var gid = stat6.gid;
       var myUid = options.uid !== void 0 ? options.uid : process.getuid && process.getuid();
       var myGid = options.gid !== void 0 ? options.gid : process.getgid && process.getgid();
       var u = parseInt("100", 8);
@@ -251,8 +255,8 @@ var require_path_key = __commonJS({
     "use strict";
     var pathKey = (options = {}) => {
       const environment = options.env || process.env;
-      const platform5 = options.platform || process.platform;
-      if (platform5 !== "win32") {
+      const platform4 = options.platform || process.platform;
+      if (platform4 !== "win32") {
         return "PATH";
       }
       return Object.keys(environment).reverse().find((key) => key.toUpperCase() === "PATH") || "Path";
@@ -455,19 +459,19 @@ var require_enoent = __commonJS({
         spawnargs: original.args
       });
     }
-    function hookChildProcess(cp2, parsed) {
+    function hookChildProcess(cp, parsed) {
       if (!isWin) {
         return;
       }
-      const originalEmit = cp2.emit;
-      cp2.emit = function(name, arg1) {
+      const originalEmit = cp.emit;
+      cp.emit = function(name, arg1) {
         if (name === "exit") {
           const err = verifyENOENT(arg1, parsed);
           if (err) {
-            return originalEmit.call(cp2, "error", err);
+            return originalEmit.call(cp, "error", err);
           }
         }
-        return originalEmit.apply(cp2, arguments);
+        return originalEmit.apply(cp, arguments);
       };
     }
     function verifyENOENT(status, parsed) {
@@ -495,18 +499,18 @@ var require_enoent = __commonJS({
 var require_cross_spawn = __commonJS({
   "../node_modules/cross-spawn/index.js"(exports, module) {
     "use strict";
-    var cp2 = __require("child_process");
+    var cp = __require("child_process");
     var parse = require_parse();
     var enoent = require_enoent();
     function spawn(command, args, options) {
       const parsed = parse(command, args, options);
-      const spawned = cp2.spawn(parsed.command, parsed.args, parsed.options);
+      const spawned = cp.spawn(parsed.command, parsed.args, parsed.options);
       enoent.hookChildProcess(spawned, parsed);
       return spawned;
     }
     function spawnSync(command, args, options) {
       const parsed = parse(command, args, options);
-      const result = cp2.spawnSync(parsed.command, parsed.args, parsed.options);
+      const result = cp.spawnSync(parsed.command, parsed.args, parsed.options);
       result.error = result.error || enoent.verifyENOENTSync(result.status, parsed);
       return result;
     }
@@ -1602,9 +1606,9 @@ var NodeFsHandler = class {
     if (this.fsw.closed) {
       return;
     }
-    const dirname7 = sysPath.dirname(file);
+    const dirname6 = sysPath.dirname(file);
     const basename3 = sysPath.basename(file);
-    const parent = this.fsw._getWatchedDir(dirname7);
+    const parent = this.fsw._getWatchedDir(dirname6);
     let prevStats = stats;
     if (parent.has(basename3))
       return;
@@ -1631,7 +1635,7 @@ var NodeFsHandler = class {
             prevStats = newStats2;
           }
         } catch (error) {
-          this.fsw._remove(dirname7, basename3);
+          this.fsw._remove(dirname6, basename3);
         }
       } else if (parent.has(basename3)) {
         const at = newStats.atimeMs;
@@ -2439,8 +2443,8 @@ var FSWatcher = class extends EventEmitter {
     }
     return this._userIgnored(path, stats);
   }
-  _isntIgnored(path, stat7) {
-    return !this._isIgnored(path, stat7);
+  _isntIgnored(path, stat6) {
+    return !this._isIgnored(path, stat6);
   }
   /**
    * Provides a set of common helpers and properties relating to symlink handling.
@@ -3259,14 +3263,11 @@ async function registerClients(options) {
   );
   if (claudeDesktop) {
     if (osPlatform2 === "win32") {
-      const cleanup = await safe("Claude Desktop", () => unregisterJsonClient("Claude Desktop", claudeDesktop, now));
-      results.push(
-        cleanup.action === "error" ? cleanup : {
-          client: "Claude Desktop",
-          action: "skipped",
-          detail: "Claude Desktop uses the packaged LLMnesia extension on Windows."
-        }
-      );
+      results.push({
+        client: "Claude Desktop",
+        action: "skipped",
+        detail: "Automatic Claude Desktop setup is not available on Windows; existing configuration was left unchanged."
+      });
     } else {
       results.push(
         await safe(
@@ -3423,100 +3424,14 @@ async function unregisterClients(options = {}) {
 }
 
 // src/doctor.ts
-import { existsSync as existsSync2, readFileSync } from "fs";
-import { delimiter, dirname as dirname6, isAbsolute as isAbsolute2, join as join6, sep } from "path";
-import { homedir as homedir4, platform as platform3 } from "os";
-
-// src/runtimeInstall.ts
-import { cp, mkdir as mkdir3, readdir as readdir3, rename, rm as rm2, writeFile as writeFile3 } from "fs/promises";
-import { existsSync } from "fs";
-import { homedir as homedir3 } from "os";
-import { dirname as dirname5, join as join5 } from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
-function defaultSourceDir() {
-  return dirname5(fileURLToPath2(import.meta.url));
-}
-function runtimeBinDir(home2 = homedir3()) {
-  return join5(home2, ".llmnesia", "bin");
-}
-async function installRuntime(options = {}) {
-  const home2 = options.home ?? homedir3();
-  const sourceDir = options.sourceDir ?? defaultSourceDir();
-  const nodePath = options.nodePath ?? process.execPath;
-  const binDir = runtimeBinDir(home2);
-  const sourceEntry = join5(sourceDir, "cli.js");
-  if (!existsSync(sourceEntry)) {
-    throw new Error(
-      `Cannot locate the built runtime: no cli.js in ${sourceDir}. Run this from an installed package (npx -y @llmnesia/mcp@latest install) or build first (npm run build).`
-    );
-  }
-  const parentDir = dirname5(binDir);
-  const nonce = `${process.pid}-${Date.now()}`;
-  const stagingDir = join5(parentDir, `.bin-install-${nonce}`);
-  const backupDir = join5(parentDir, `.bin-backup-${nonce}`);
-  await mkdir3(parentDir, { recursive: true });
-  await rm2(stagingDir, { recursive: true, force: true });
-  await rm2(backupDir, { recursive: true, force: true });
-  await mkdir3(stagingDir, { recursive: true });
-  try {
-    for (const name of await readdir3(sourceDir)) {
-      await cp(join5(sourceDir, name), join5(stagingDir, name), { recursive: true });
-    }
-    await writeFile3(
-      join5(stagingDir, "package.json"),
-      `${JSON.stringify(
-        {
-          name: "llmnesia-mcp-runtime",
-          private: true,
-          type: "module",
-          comment: "Installed copy of @llmnesia/mcp's dist. Managed by the LLMnesia installer; edits are lost on reinstall."
-        },
-        null,
-        2
-      )}
-`,
-      "utf8"
-    );
-    const hadPreviousRuntime = existsSync(binDir);
-    if (hadPreviousRuntime) {
-      await rename(binDir, backupDir);
-    }
-    try {
-      await rename(stagingDir, binDir);
-    } catch (err) {
-      if (hadPreviousRuntime && !existsSync(binDir) && existsSync(backupDir)) {
-        await rename(backupDir, binDir);
-      }
-      throw err;
-    }
-    await rm2(backupDir, { recursive: true, force: true });
-  } finally {
-    await rm2(stagingDir, { recursive: true, force: true });
-  }
-  const entry = join5(binDir, "cli.js");
-  return {
-    binDir,
-    entry,
-    serve: { command: nodePath, args: [entry, "serve"] },
-    sourceDir,
-    nodePath
-  };
-}
-async function uninstallRuntime(home2 = homedir3()) {
-  const binDir = runtimeBinDir(home2);
-  if (!existsSync(binDir)) {
-    return null;
-  }
-  await rm2(binDir, { recursive: true, force: true });
-  return binDir;
-}
-
-// src/doctor.ts
+import { existsSync, readFileSync } from "fs";
+import { delimiter, dirname as dirname5, isAbsolute as isAbsolute2, join as join5, sep } from "path";
+import { homedir as homedir3, platform as platform3 } from "os";
 var INSTALL_COMMAND = "npx -y @llmnesia/mcp@latest install";
 function checkNativeHostManifest(home2, osPlatform2) {
   if (osPlatform2 === "win32") {
-    const manifestPath = join6(home2, ".llmnesia", `${HOST_NAME}.json`);
-    if (existsSync2(manifestPath)) {
+    const manifestPath = join5(home2, ".llmnesia", `${HOST_NAME}.json`);
+    if (existsSync(manifestPath)) {
       return {
         name: "Native messaging host",
         status: "ok",
@@ -3531,11 +3446,11 @@ function checkNativeHostManifest(home2, osPlatform2) {
   }
   const found = [];
   for (const [label, browserDir] of posixBrowsers(home2, osPlatform2)) {
-    if (!existsSync2(browserDir)) {
+    if (!existsSync(browserDir)) {
       continue;
     }
-    const manifestPath = join6(browserDir, "NativeMessagingHosts", `${HOST_NAME}.json`);
-    if (existsSync2(manifestPath)) {
+    const manifestPath = join5(browserDir, "NativeMessagingHosts", `${HOST_NAME}.json`);
+    if (existsSync(manifestPath)) {
       found.push(label);
     }
   }
@@ -3549,8 +3464,8 @@ function checkNativeHostManifest(home2, osPlatform2) {
   };
 }
 async function checkCorpus(home2, corpusRoot) {
-  const configPath = join6(home2, ".llmnesia", "config.json");
-  if (!corpusRoot && !existsSync2(configPath)) {
+  const configPath = join5(home2, ".llmnesia", "config.json");
+  if (!corpusRoot && !existsSync(configPath)) {
     return {
       name: "Corpus config",
       status: "missing",
@@ -3558,7 +3473,7 @@ async function checkCorpus(home2, corpusRoot) {
     };
   }
   const root = corpusRoot ?? resolveCorpusDir();
-  if (!existsSync2(root)) {
+  if (!existsSync(root)) {
     return {
       name: "Corpus",
       status: "warn",
@@ -3591,14 +3506,14 @@ async function checkCorpus(home2, corpusRoot) {
 function commandProblem(command, args = []) {
   const looksLikePath = isAbsolute2(command) || command.includes(sep) || command.includes("/");
   if (looksLikePath) {
-    if (!existsSync2(command)) {
+    if (!existsSync(command)) {
       return `its command does not exist: ${command}`;
     }
   } else if (!resolveOnPath(command)) {
     return `its command "${command}" is not on PATH. GUI clients get a minimal PATH (no nvm, no homebrew), so a bare command name is unreliable even when your shell can find it. Re-run: ${INSTALL_COMMAND}`;
   }
   const script = args.find((a) => a.endsWith(".js") || a.endsWith(".mjs"));
-  if (script && (isAbsolute2(script) || script.includes(sep)) && !existsSync2(script)) {
+  if (script && (isAbsolute2(script) || script.includes(sep)) && !existsSync(script)) {
     return `its script does not exist: ${script}. Re-run: ${INSTALL_COMMAND}`;
   }
   return null;
@@ -3610,29 +3525,72 @@ function resolveOnPath(command) {
       continue;
     }
     for (const ext of exts) {
-      if (existsSync2(join6(dir, command + ext))) {
+      if (existsSync(join5(dir, command + ext))) {
         return true;
       }
     }
   }
   return false;
 }
+function installedRuntimeVersion(home2) {
+  try {
+    const parsed = JSON.parse(readFileSync(join5(runtimeBinDir(home2), "package.json"), "utf8"));
+    return typeof parsed.version === "string" ? parsed.version : null;
+  } catch {
+    return null;
+  }
+}
 function checkRuntime(home2) {
-  const entry = join6(runtimeBinDir(home2), "cli.js");
-  if (existsSync2(entry)) {
-    return { name: "MCP server runtime", status: "ok", detail: `Installed at ${entry}.` };
+  const entry = join5(runtimeBinDir(home2), "cli.js");
+  if (!existsSync(entry)) {
+    return {
+      name: "MCP server runtime",
+      status: "missing",
+      detail: `No runtime at ${entry}. Clients spawn this copy, so registration alone is not enough. Run: ${INSTALL_COMMAND}`
+    };
   }
-  return {
-    name: "MCP server runtime",
-    status: "missing",
-    detail: `No runtime at ${entry}. Clients spawn this copy, so registration alone is not enough. Run: ${INSTALL_COMMAND}`
-  };
+  const installed = installedRuntimeVersion(home2);
+  if (installed === null) {
+    return {
+      name: "MCP server runtime",
+      status: "warn",
+      detail: `Installed at ${entry}, but its version is not recorded, so it predates automatic updates. Refresh it with: ${INSTALL_COMMAND}`
+    };
+  }
+  const suffix = installed === VERSION ? "" : ` (this command is ${VERSION})`;
+  return { name: "MCP server runtime", status: "ok", detail: `Version ${installed} at ${entry}${suffix}.` };
+}
+function checkAutoUpdate(home2, env) {
+  const name = "Automatic updates";
+  if (isSelfUpdateDisabled(env)) {
+    return { name, status: "warn", detail: "Turned off by LLMNESIA_NO_AUTO_UPDATE." };
+  }
+  let state = {};
+  try {
+    state = JSON.parse(readFileSync(join5(home2, ".llmnesia", "update-state.json"), "utf8"));
+  } catch {
+    return {
+      name,
+      status: "ok",
+      detail: "On. No check has run yet; the server checks shortly after it starts."
+    };
+  }
+  if (state.lastFailedVersion) {
+    return {
+      name,
+      status: "warn",
+      detail: `On, but ${state.lastFailedVersion} could not be installed automatically. Run: ${INSTALL_COMMAND}`
+    };
+  }
+  const checkedAt = state.lastCheckedAt ? new Date(state.lastCheckedAt).toISOString() : "never";
+  const latest = state.lastSeenVersion ? `; latest published ${state.lastSeenVersion}` : "";
+  return { name, status: "ok", detail: `On. Last checked ${checkedAt}${latest}.` };
 }
 async function checkJsonClient(label, configPath) {
-  if (!existsSync2(dirname6(configPath))) {
-    return { name: label, status: "warn", detail: `Not installed (no ${dirname6(configPath)}).` };
+  if (!existsSync(dirname5(configPath))) {
+    return { name: label, status: "warn", detail: `Not installed (no ${dirname5(configPath)}).` };
   }
-  if (!existsSync2(configPath)) {
+  if (!existsSync(configPath)) {
     return {
       name: label,
       status: "missing",
@@ -3721,8 +3679,8 @@ async function checkCodex(home2, cli) {
       return { name: "Codex", status: "warn", detail: `Could not inspect Codex MCP settings: ${err instanceof Error ? err.message : String(err)}` };
     }
   }
-  const configPath = join6(home2, ".codex", "config.toml");
-  if (!existsSync2(configPath)) {
+  const configPath = join5(home2, ".codex", "config.toml");
+  if (!existsSync(configPath)) {
     return { name: "Codex", status: "warn", detail: `Not installed (no ${configPath}), or never configured.` };
   }
   let text;
@@ -3750,11 +3708,11 @@ async function checkCodex(home2, cli) {
   };
 }
 async function runDoctor(options = {}) {
-  const home2 = options.home ?? homedir4();
+  const home2 = options.home ?? homedir3();
   const osPlatform2 = options.osPlatform ?? platform3();
   const claudeCli = options.claudeCli ?? realClaudeCli;
   const codexCli = options.codexCli ?? realCodexCli;
-  const claudeDesktopPath = osPlatform2 === "darwin" ? join6(home2, "Library", "Application Support", "Claude", "claude_desktop_config.json") : osPlatform2 === "win32" ? join6(process.env.APPDATA || join6(home2, "AppData", "Roaming"), "Claude", "claude_desktop_config.json") : null;
+  const claudeDesktopPath = osPlatform2 === "darwin" ? join5(home2, "Library", "Application Support", "Claude", "claude_desktop_config.json") : osPlatform2 === "win32" ? join5(process.env.APPDATA || join5(home2, "AppData", "Roaming"), "Claude", "claude_desktop_config.json") : null;
   const checks = [];
   const run = async (name, fn) => {
     try {
@@ -3769,11 +3727,12 @@ async function runDoctor(options = {}) {
   };
   await run("Native messaging host", () => checkNativeHostManifest(home2, osPlatform2));
   await run("MCP server runtime", () => checkRuntime(home2));
+  await run("Automatic updates", () => checkAutoUpdate(home2, options.env ?? process.env));
   await run("Corpus", () => checkCorpus(home2, options.corpusRoot));
   if (claudeDesktopPath) {
     await run("Claude Desktop", () => checkJsonClient("Claude Desktop", claudeDesktopPath));
   }
-  await run("Cursor", () => checkJsonClient("Cursor", join6(home2, ".cursor", "mcp.json")));
+  await run("Cursor", () => checkJsonClient("Cursor", join5(home2, ".cursor", "mcp.json")));
   await run("Claude Code", () => checkClaudeCode(claudeCli));
   await run("Codex", () => checkCodex(home2, codexCli));
   checks.push({
@@ -3788,36 +3747,6 @@ function formatDoctorReport(report) {
   return report.checks.map((c) => `${icon[c.status]} ${c.name}: ${c.detail}`).join("\n");
 }
 
-// src/claudeDesktopExtension.ts
-import { execFile as execFile3 } from "child_process";
-import { access as access2, stat as stat6 } from "fs/promises";
-import { homedir as homedir5, platform as platform4 } from "os";
-import { join as join7 } from "path";
-import { promisify as promisify3 } from "util";
-var execFileAsync3 = promisify3(execFile3);
-async function defaultOpenBundle(bundlePath) {
-  await execFileAsync3("rundll32.exe", ["url.dll,FileProtocolHandler", bundlePath], { windowsHide: true });
-}
-async function promptClaudeDesktopExtension(options) {
-  const home2 = options.home ?? homedir5();
-  const osPlatform2 = options.osPlatform ?? platform4();
-  const bundlePath = join7(options.binDir, "llmnesia.mcpb");
-  if (osPlatform2 !== "win32") {
-    return { status: "unsupported", bundlePath };
-  }
-  const appData = options.appData ?? process.env.APPDATA ?? join7(home2, "AppData", "Roaming");
-  try {
-    if (!(await stat6(join7(appData, "Claude"))).isDirectory()) {
-      return { status: "not-installed", bundlePath };
-    }
-  } catch {
-    return { status: "not-installed", bundlePath };
-  }
-  await access2(bundlePath);
-  await (options.openBundle ?? defaultOpenBundle)(bundlePath);
-  return { status: "opened", bundlePath };
-}
-
 // src/cli.ts
 var USAGE = `llmnesia-mcp ${VERSION}
 
@@ -3890,7 +3819,7 @@ function summarizeClientRegistrations(results) {
   return { connected, prepared, errors };
 }
 function formatInstallSuccess() {
-  return "\nSetup complete.\nFully close and reopen your browser and any desktop AI app you use.\nLLMnesia will be available in each supported desktop AI app you use.\nLLMnesia Settings will confirm when your history is ready.\n";
+  return "\nSetup complete.\nFully close and reopen your browser and any desktop AI app you use.\nLLMnesia will be available in the desktop AI apps connected during setup.\nLLMnesia Settings will confirm when your history is ready.\n\nLLMnesia keeps itself up to date, checking for a new version once a day.\nOnly a version number is fetched. Your conversations never leave this machine.\nTo turn updates off, set LLMNESIA_NO_AUTO_UPDATE=1.\n";
 }
 async function runInstall(positionals, options, flags) {
   let hadProblems = false;
@@ -3929,19 +3858,6 @@ async function runInstall(positionals, options, flags) {
 `);
   }
   hadProblems ||= registrations.errors.length > 0;
-  if (process.platform === "win32") {
-    try {
-      const claude = await promptClaudeDesktopExtension({ binDir: runtime.binDir });
-      if (claude.status === "opened") {
-        process.stdout.write("Claude opened. Click Install to add LLMnesia.\n");
-      }
-    } catch (err) {
-      process.stderr.write(
-        `Claude Desktop needs one more step: open ${runtime.binDir}\\llmnesia.mcpb and click Install. (${err instanceof Error ? err.message : String(err)})
-`
-      );
-    }
-  }
   if (hadProblems) {
     process.stderr.write("\nSetup needs attention. Fix the message above, then run the same command again.\n");
     return 1;

package/dist/cli.js

@@ -3,7 +3,7 @@ import { createRequire as __llmnesiaCreateRequire } from "node:module";
 const require = __llmnesiaCreateRequire(import.meta.url);
 import {
   VERSION
-} from "./chunk-MI5RBP7Y.js";
+} from "./chunk-QGVH3T5W.js";
 
 // src/nodeDownload.ts
 var NODE_DOWNLOAD_URLS = {
@@ -141,7 +141,7 @@ async function bootstrap() {
     await guideUnsupportedNodeVersion(process.versions.node);
     return 1;
   }
-  const { main } = await import("./cli-GKHVUCEP.js");
+  const { main } = await import("./cli-I2P4TSZW.js");
   return main();
 }
 bootstrap().then((code) => {

package/dist/mcp.js

@@ -3,17 +3,19 @@ import { createRequire as __llmnesiaCreateRequire } from "node:module";
 const require = __llmnesiaCreateRequire(import.meta.url);
 import {
   Corpus,
+  describeOutcome,
   drainInbox,
   openSearchIndex,
   pendingInboxFiles,
-  resolveCorpusDir
-} from "./chunk-3JQ7CGCP.js";
+  resolveCorpusDir,
+  scheduleSelfUpdate
+} from "./chunk-JS2GFGNW.js";
 import {
   VERSION,
   __commonJS,
   __export,
   __toESM
-} from "./chunk-MI5RBP7Y.js";
+} from "./chunk-QGVH3T5W.js";
 
 // ../node_modules/ajv/dist/compile/codegen/code.js
 var require_code = __commonJS({
@@ -21632,29 +21634,41 @@ async function runServe() {
       return jsonResult(status);
     })
   );
-  server.registerTool(
-    "save_conversation",
-    {
-      title: "Save conversation",
-      description: "Add or update a conversation in the user's local corpus. Provide platform, title, and the messages; identity is keyed on docId (or platform:sourceId), so re-saving the same conversation updates it in place.",
-      inputSchema: saveConversationSchema.shape,
-      annotations: {
-        readOnlyHint: false,
-        destructiveHint: false,
-        idempotentHint: false,
-        openWorldHint: false
-      }
-    },
-    async (args) => withService(async (service2) => {
-      try {
-        const result = await service2.saveConversation(args);
-        return jsonResult(result);
-      } catch (err) {
-        return errorResult(`save_conversation failed: ${err instanceof Error ? err.message : String(err)}`);
+  if (process.env.LLMNESIA_READ_ONLY !== "1") {
+    server.registerTool(
+      "save_conversation",
+      {
+        title: "Save conversation",
+        description: "Add or update a conversation in the user's local corpus. Provide platform, title, and the messages; identity is keyed on docId (or platform:sourceId), so re-saving the same conversation updates it in place.",
+        inputSchema: saveConversationSchema.shape,
+        annotations: {
+          readOnlyHint: false,
+          destructiveHint: false,
+          idempotentHint: false,
+          openWorldHint: false
+        }
+      },
+      async (args) => withService(async (service2) => {
+        try {
+          const result = await service2.saveConversation(args);
+          return jsonResult(result);
+        } catch (err) {
+          return errorResult(`save_conversation failed: ${err instanceof Error ? err.message : String(err)}`);
+        }
+      })
+    );
+  }
+  server.server.oninitialized = () => {
+    service.start();
+    scheduleSelfUpdate({
+      onOutcome: (outcome) => {
+        if (outcome.action === "updated" || outcome.action === "update-failed") {
+          process.stderr.write(`llmnesia: ${describeOutcome(outcome)}
+`);
+        }
       }
-    })
-  );
-  server.server.oninitialized = () => service.start();
+    });
+  };
   const transport = new StdioServerTransport();
   await server.connect(transport);
   process.stderr.write(`llmnesia MCP protocol ready; waiting for client initialization (${root})

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@llmnesia/mcp",
-  "version": "0.1.12",
+  "version": "0.1.14",
   "private": false,
   "type": "module",
   "comment:mcpName": "The MCP Registry's ownership marker: it must equal server.json's `name`, and the namespace must match how you authenticate with mcp-publisher. `com.llmnesia/...` requires DNS auth (a TXT record on llmnesia.com) — see docs/MCP_INSTALLER_BOARD.md.",

package/server.json

@@ -3,13 +3,13 @@
   "name": "com.llmnesia/mcp",
   "title": "LLMnesia",
   "description": "Search your AI chat history from Claude, Cursor, Codex, and other MCP clients.",
-  "version": "0.1.12",
+  "version": "0.1.14",
   "packages": [
     {
       "registryType": "npm",
       "registryBaseUrl": "https://registry.npmjs.org",
       "identifier": "@llmnesia/mcp",
-      "version": "0.1.12",
+      "version": "0.1.14",
       "transport": {
         "type": "stdio"
       }