@softeria/ms-365-mcp-server 0.137.0 → 0.139.0

package/README.md

@@ -630,11 +630,23 @@ Environment variables:
 
 ## Token Storage
 
-Authentication tokens are stored using the OS credential store (via keytar) when available. If keytar is not installed or fails (common on headless Linux), the server falls back to file-based storage.
+Authentication tokens are stored in an encrypted file (AES-256-GCM). Only the 32-byte encryption key goes to the OS credential store via keytar.
 
-**Default fallback paths** are relative to the installed package directory. This means tokens can be lost when the package is reinstalled or updated via npm.
+The cache itself is too big for some credential stores to hold - a Windows Credential Manager blob caps out at 2560 bytes and a real token cache is several times that, so on Windows the write could never succeed. A key is 32 bytes regardless of how many accounts are signed in, so this works the same way on every platform.
 
-To persist tokens across updates, set custom paths outside the package directory:
+**Default paths** are in the per-user config directory:
+
+| Platform | Location                                                                  |
+| -------- | ------------------------------------------------------------------------- |
+| Windows  | `%APPDATA%\ms-365-mcp-server\`                                            |
+| macOS    | `~/Library/Application Support/ms-365-mcp-server/`                        |
+| Linux    | `$XDG_CONFIG_HOME/ms-365-mcp-server/` (or `~/.config/ms-365-mcp-server/`) |
+
+Earlier versions defaulted to a path inside the installed package, which under `npx` resolves to a content-hashed cache directory that `npm cache clean` or a version bump throws away. A cache still sitting in the package directory is moved to the new location on first run.
+
+That covers global and local installs, and `npx` when the hash has not changed. It cannot reach a cache left behind in a _previous_ `npx` hash directory, so upgrading an `npx` install one last time means signing in again. Adopting a cache from another directory would mean trusting a directory this package cannot prove it wrote, which is not worth one saved sign-in.
+
+Override the paths if you need to:
 
 ```bash
 export MS365_MCP_TOKEN_CACHE_PATH="$HOME/.config/ms365-mcp/.token-cache.json"
@@ -643,7 +655,11 @@ export MS365_MCP_SELECTED_ACCOUNT_PATH="$HOME/.config/ms365-mcp/.selected-accoun
 
 Parent directories are created automatically. Files are written with `0600` permissions.
 
-> **Security note**: File-based token storage writes sensitive credentials to disk. Ensure the chosen directory has appropriate access controls. The OS credential store (keytar) is preferred when available.
+**Without a credential store** (headless Linux, most containers) the key is written to `.cache-key` next to the cache file, with `0600` permissions. That stops the tokens showing up in a stray `cat`, a backup or an accidental commit. It does not protect against anyone who can already read the directory - the key is right there. Use `MS365_MCP_AUTH_CACHE_COMMAND` below if you need the cache in a real secret store.
+
+If the cache cannot be decrypted - key lost, keychain locked, file modified - you are asked to sign in again rather than the server failing to start. The cache file is left exactly as it was: not deleted, and not overwritten by that new sign-in either. A keychain that is merely locked usually reads fine on the next start, and the cache is still there when it does.
+
+The cost is that the new session is not saved while this lasts, so each start asks you to sign in again. If the key is genuinely gone and the cache will never open, delete `.token-cache.json` to start over - the log says so, and names the path.
 
 > **Hosted/sandboxed environments** (e.g. Anthropic Cowork): Set `MS365_MCP_TOKEN_CACHE_PATH` and `MS365_MCP_SELECTED_ACCOUNT_PATH` to a persistent mount so tokens survive between sessions.
 

package/dist/lib/cache-encryption.js

@@ -0,0 +1,89 @@
+import { createCipheriv, createDecipheriv, randomBytes } from "node:crypto";
+const ALGORITHM = "aes-256-gcm";
+const ALGORITHM_LABEL = "A256GCM";
+const ENVELOPE_VERSION = 2;
+const IV_BYTES = 12;
+const TAG_BYTES = 16;
+const CACHE_KEY_BYTES = 32;
+function generateCacheKey() {
+  return randomBytes(CACHE_KEY_BYTES);
+}
+function parseCacheKey(encoded) {
+  const key = Buffer.from(encoded.trim(), "base64");
+  if (key.length !== CACHE_KEY_BYTES) {
+    throw new Error(`Auth cache key must be ${CACHE_KEY_BYTES} bytes, got ${key.length}`);
+  }
+  return key;
+}
+function encodeCacheKey(key) {
+  return key.toString("base64");
+}
+function additionalData(purpose) {
+  return Buffer.from(`ms365:v${ENVELOPE_VERSION}:${ALGORITHM_LABEL}:${purpose}`, "utf8");
+}
+function encryptCache(plaintext, key, purpose) {
+  const iv = randomBytes(IV_BYTES);
+  const cipher = createCipheriv(ALGORITHM, key, iv);
+  cipher.setAAD(additionalData(purpose));
+  const ciphertext = Buffer.concat([cipher.update(plaintext, "utf8"), cipher.final()]);
+  const envelope = {
+    _cacheEnvelope: true,
+    v: ENVELOPE_VERSION,
+    alg: ALGORITHM_LABEL,
+    iv: iv.toString("base64"),
+    tag: cipher.getAuthTag().toString("base64"),
+    data: ciphertext.toString("base64")
+  };
+  return JSON.stringify(envelope);
+}
+function isEncryptedCache(raw) {
+  return readEnvelope(raw) !== void 0;
+}
+function decryptCache(raw, key, purpose) {
+  const envelope = readEnvelope(raw);
+  if (!envelope) {
+    throw new Error("Auth cache is not an encrypted envelope");
+  }
+  if (envelope.v !== ENVELOPE_VERSION) {
+    throw new Error(`Unsupported auth cache envelope version: ${envelope.v}`);
+  }
+  if (envelope.alg !== ALGORITHM_LABEL) {
+    throw new Error(`Unsupported auth cache algorithm: ${envelope.alg}`);
+  }
+  if (typeof envelope.iv !== "string" || typeof envelope.tag !== "string" || typeof envelope.data !== "string") {
+    throw new Error("Auth cache envelope is missing iv, tag or data");
+  }
+  const iv = Buffer.from(envelope.iv, "base64");
+  const tag = Buffer.from(envelope.tag, "base64");
+  if (iv.length !== IV_BYTES || tag.length !== TAG_BYTES) {
+    throw new Error("Auth cache envelope has a malformed iv or tag");
+  }
+  const decipher = createDecipheriv(ALGORITHM, key, iv);
+  decipher.setAAD(additionalData(purpose));
+  decipher.setAuthTag(tag);
+  return Buffer.concat([
+    decipher.update(Buffer.from(envelope.data, "base64")),
+    decipher.final()
+  ]).toString("utf8");
+}
+function readEnvelope(raw) {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return void 0;
+  }
+  if (!parsed || typeof parsed !== "object") return void 0;
+  const candidate = parsed;
+  if (candidate._cacheEnvelope !== true || typeof candidate.v !== "number") return void 0;
+  return candidate;
+}
+export {
+  CACHE_KEY_BYTES,
+  decryptCache,
+  encodeCacheKey,
+  encryptCache,
+  generateCacheKey,
+  isEncryptedCache,
+  parseCacheKey
+};

package/dist/lib/config-paths.js

@@ -0,0 +1,20 @@
+import os from "node:os";
+import path from "node:path";
+const APP_DIR_NAME = "ms-365-mcp-server";
+function getConfigDir() {
+  if (process.platform === "win32") {
+    const appData = process.env.APPDATA?.trim();
+    return path.join(appData || path.join(os.homedir(), "AppData", "Roaming"), APP_DIR_NAME);
+  }
+  if (process.platform === "darwin") {
+    return path.join(os.homedir(), "Library", "Application Support", APP_DIR_NAME);
+  }
+  const xdg = process.env.XDG_CONFIG_HOME?.trim();
+  if (xdg && path.isAbsolute(xdg)) {
+    return path.join(xdg, APP_DIR_NAME);
+  }
+  return path.join(os.homedir(), ".config", APP_DIR_NAME);
+}
+export {
+  getConfigDir
+};

package/dist/server.js

@@ -479,48 +479,16 @@ class MicrosoftGraphServer {
         allowUnauthenticatedDiscovery: this.options.allowUnauthenticatedDiscovery,
         publicUrl: publicBase
       });
-      app.get(
-        "/mcp",
-        mcpAuth,
-        async (req, res) => {
-          const handler = async () => {
-            const server = this.createMcpServer();
-            const transport = new StreamableHTTPServerTransport({
-              sessionIdGenerator: void 0
-              // Stateless mode
-            });
-            res.on("close", () => {
-              transport.close();
-              server.close();
-            });
-            await server.connect(transport);
-            await transport.handleRequest(req, res, void 0);
-          };
-          try {
-            if (req.microsoftAuth) {
-              let accessToken = req.microsoftAuth.accessToken;
-              if (this.oboClient) {
-                accessToken = await this.oboClient.exchangeToken(accessToken);
-              }
-              await requestContext.run({ accessToken }, handler);
-            } else {
-              await handler();
-            }
-          } catch (error) {
-            logger.error("Error handling MCP GET request:", error);
-            if (!res.headersSent) {
-              res.status(500).json({
-                jsonrpc: "2.0",
-                error: {
-                  code: -32603,
-                  message: "Internal server error"
-                },
-                id: null
-              });
-            }
-          }
-        }
-      );
+      app.get("/mcp", (req, res) => {
+        res.status(405).json({
+          jsonrpc: "2.0",
+          error: {
+            code: -32e3,
+            message: "Method not allowed."
+          },
+          id: null
+        });
+      });
       app.post(
         "/mcp",
         mcpAuth,
@@ -528,8 +496,10 @@ class MicrosoftGraphServer {
           const handler = async () => {
             const server = this.createMcpServer();
             const transport = new StreamableHTTPServerTransport({
-              sessionIdGenerator: void 0
+              sessionIdGenerator: void 0,
               // Stateless mode
+              enableJsonResponse: true
+              // Reply to POSTs with plain JSON, not one-shot SSE
             });
             res.on("close", () => {
               transport.close();

package/dist/token-cache-storage.js

@@ -1,7 +1,17 @@
 import { spawn } from "node:child_process";
+import { randomBytes } from "node:crypto";
 import fs, { existsSync, readFileSync } from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
+import {
+  decryptCache,
+  encodeCacheKey,
+  encryptCache,
+  generateCacheKey,
+  isEncryptedCache,
+  parseCacheKey
+} from "./lib/cache-encryption.js";
+import { getConfigDir } from "./lib/config-paths.js";
 import logger from "./logger.js";
 const SERVICE_NAME = "ms-365-mcp-server";
 const TOKEN_CACHE_ACCOUNT = "msal-token-cache";
@@ -11,11 +21,12 @@ const AUTH_CACHE_COMMAND_TIMEOUT_ENV = "MS365_MCP_AUTH_CACHE_COMMAND_TIMEOUT_MS"
 const DEFAULT_AUTH_CACHE_COMMAND_TIMEOUT_MS = 1e4;
 const STDERR_LIMIT = 2048;
 const COMMAND_KILL_GRACE_MS = 1e3;
+const CACHE_KEY_ACCOUNT = "cache-key";
+const TOKEN_CACHE_FILE = ".token-cache.json";
+const SELECTED_ACCOUNT_FILE = ".selected-account.json";
+const CACHE_KEY_FILE = ".cache-key";
 const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-const FALLBACK_DIR = __dirname;
-const DEFAULT_TOKEN_CACHE_PATH = path.join(FALLBACK_DIR, "..", ".token-cache.json");
-const DEFAULT_SELECTED_ACCOUNT_PATH = path.join(FALLBACK_DIR, "..", ".selected-account.json");
+const LEGACY_DIR = path.join(path.dirname(__filename), "..");
 let keytar = null;
 async function getKeytar() {
   if (keytar === void 0) {
@@ -64,11 +75,68 @@ function pickNewestRaw(keytarRaw, fileRaw) {
 }
 function getTokenCachePath() {
   const envPath = process.env.MS365_MCP_TOKEN_CACHE_PATH?.trim();
-  return envPath || DEFAULT_TOKEN_CACHE_PATH;
+  return envPath || path.join(getConfigDir(), TOKEN_CACHE_FILE);
 }
 function getSelectedAccountPath() {
   const envPath = process.env.MS365_MCP_SELECTED_ACCOUNT_PATH?.trim();
-  return envPath || DEFAULT_SELECTED_ACCOUNT_PATH;
+  return envPath || path.join(getConfigDir(), SELECTED_ACCOUNT_FILE);
+}
+function getCacheKeyPath() {
+  return path.join(path.dirname(getTokenCachePath()), CACHE_KEY_FILE);
+}
+let legacyPathsMigrated = false;
+function migrateLegacyPaths() {
+  if (legacyPathsMigrated) return;
+  legacyPathsMigrated = true;
+  migrateLegacyPathsFrom(LEGACY_DIR);
+}
+function migrateLegacyPathsFrom(legacyDir) {
+  const moves = [
+    [TOKEN_CACHE_FILE, getTokenCachePath(), process.env.MS365_MCP_TOKEN_CACHE_PATH?.trim()],
+    [
+      SELECTED_ACCOUNT_FILE,
+      getSelectedAccountPath(),
+      process.env.MS365_MCP_SELECTED_ACCOUNT_PATH?.trim()
+    ]
+  ];
+  for (const [fileName, target, envOverride] of moves) {
+    if (envOverride || existsSync(target)) continue;
+    const legacyPath = path.join(legacyDir, fileName);
+    if (!existsSync(legacyPath) || existsSync(`${legacyPath}.migrated`)) continue;
+    let moved = false;
+    try {
+      ensureParentDir(target);
+      fs.renameSync(legacyPath, target);
+      moved = true;
+    } catch {
+      try {
+        ensureParentDir(target);
+        fs.copyFileSync(legacyPath, target);
+        moved = true;
+        try {
+          fs.unlinkSync(legacyPath);
+        } catch {
+          logger.warn(`Copied auth cache to ${target} but could not remove ${legacyPath}`);
+          try {
+            fs.writeFileSync(`${legacyPath}.migrated`, "", { mode: 384 });
+          } catch {
+          }
+        }
+      } catch (copyError) {
+        logger.warn(
+          `Could not migrate auth cache ${fileName} to ${target}: ${copyError.message}`
+        );
+      }
+    }
+    if (!moved) continue;
+    if (tightenPermissions(target)) {
+      logger.info(`Moved auth cache ${fileName} out of the package directory to ${target}`);
+    } else {
+      logger.error(
+        `Moved auth cache ${fileName} to ${target}, but could not make it owner-only. It holds credentials in plaintext until the next save re-encrypts it - restrict it by hand, or delete it and sign in again.`
+      );
+    }
+  }
 }
 function storageAccountForKey(key) {
   assertValidKey(key);
@@ -83,56 +151,268 @@ function assertValidKey(key) {
     throw new Error(`Unknown auth cache storage key: ${String(key)}`);
   }
 }
+function tightenPermissions(filePath) {
+  try {
+    fs.chmodSync(filePath, 384);
+    return true;
+  } catch (error) {
+    logger.warn(`Could not restrict permissions on ${filePath}: ${error.message}`);
+    return process.platform === "win32";
+  }
+}
 function ensureParentDir(filePath) {
   const dir = path.dirname(filePath);
   fs.mkdirSync(dir, { recursive: true, mode: 448 });
 }
 function writeFileAtomically(filePath, value) {
   ensureParentDir(filePath);
-  const tempPath = path.join(
-    path.dirname(filePath),
-    `.${path.basename(filePath)}.${process.pid}.${Date.now()}.tmp`
-  );
+  const tempPath = tempPathFor(filePath);
   fs.writeFileSync(tempPath, value, { mode: 384 });
   fs.renameSync(tempPath, filePath);
 }
+let keyStatePromise;
+let encryptionKeyPromise;
+const legacyKeytarEntries = /* @__PURE__ */ new Set();
+const warnedUndecryptable = /* @__PURE__ */ new Set();
+function resetCacheKeyForTests() {
+  keyStatePromise = void 0;
+  encryptionKeyPromise = void 0;
+  legacyKeytarEntries.clear();
+  warnedUndecryptable.clear();
+  legacyPathsMigrated = false;
+}
+async function clearLegacyKeytarEntry(key) {
+  if (!legacyKeytarEntries.delete(key)) return;
+  try {
+    const kt = await getKeytar();
+    if (kt) {
+      await kt.deletePassword(SERVICE_NAME, storageAccountForKey(key));
+      logger.info(`Removed the pre-encryption keychain entry for ${key}`);
+    }
+  } catch (error) {
+    logger.warn(
+      `Could not remove the legacy keychain entry for ${key}: ${error.message}`
+    );
+  }
+}
+function loadKeyState() {
+  if (!keyStatePromise) keyStatePromise = readCacheKeys();
+  return keyStatePromise;
+}
+async function readCacheKeys() {
+  const keys = [];
+  let canUseKeychain = false;
+  const kt = await getKeytar();
+  if (kt) {
+    let stored = null;
+    try {
+      stored = await kt.getPassword(SERVICE_NAME, CACHE_KEY_ACCOUNT);
+      canUseKeychain = true;
+    } catch (error) {
+      logger.warn(`Keychain access failed for the auth cache key: ${error.message}`);
+    }
+    if (stored) {
+      try {
+        keys.push(parseCacheKey(stored));
+      } catch (error) {
+        logger.warn(
+          `Ignoring unusable auth cache key in the keychain: ${error.message}`
+        );
+      }
+    }
+  }
+  let fileKeyIndex;
+  const keyPath = getCacheKeyPath();
+  if (existsSync(keyPath)) {
+    try {
+      keys.push(parseCacheKey(readFileSync(keyPath, "utf8")));
+      fileKeyIndex = keys.length - 1;
+    } catch (error) {
+      logger.warn(`Ignoring unusable auth cache key file: ${error.message}`);
+    }
+  }
+  return { keys, fileKeyIndex, canUseKeychain };
+}
+function getEncryptionKey() {
+  if (!encryptionKeyPromise) {
+    encryptionKeyPromise = resolveEncryptionKey().catch((error) => {
+      encryptionKeyPromise = void 0;
+      keyStatePromise = void 0;
+      throw error;
+    });
+  }
+  return encryptionKeyPromise;
+}
+async function resolveEncryptionKey() {
+  const state = await loadKeyState();
+  const preferred = state.keys[state.fileKeyIndex ?? 0];
+  if (preferred) return preferred;
+  const minted = await persistCacheKey(generateCacheKey(), state.canUseKeychain);
+  state.keys.unshift(minted);
+  if (state.fileKeyIndex !== void 0) state.fileKeyIndex += 1;
+  return minted;
+}
+async function persistCacheKey(key, canUseKeychain) {
+  const encoded = encodeCacheKey(key);
+  if (canUseKeychain) {
+    const kt = await getKeytar();
+    if (kt) {
+      try {
+        await kt.setPassword(SERVICE_NAME, CACHE_KEY_ACCOUNT, encoded);
+        const winner = await kt.getPassword(SERVICE_NAME, CACHE_KEY_ACCOUNT);
+        if (winner && winner !== encoded) {
+          logger.info("Another process stored an auth cache key first, adopting it");
+          return parseCacheKey(winner);
+        }
+        logger.info("Stored a new auth cache key in the system keychain");
+        return key;
+      } catch (error) {
+        logger.warn(`Keychain save failed for the auth cache key: ${error.message}`);
+      }
+    }
+  }
+  const keyPath = getCacheKeyPath();
+  if (createFileExclusively(keyPath, encoded)) {
+    logger.info(
+      `No usable system keychain; auth cache key written to ${keyPath}. Encryption guards against casual disclosure only when the key sits beside the cache.`
+    );
+    return key;
+  }
+  try {
+    const existing = parseCacheKey(readFileSync(keyPath, "utf8"));
+    logger.info("Another process created the auth cache key file first, adopting it");
+    return existing;
+  } catch (parseError) {
+    logger.warn(
+      `Replacing an unusable auth cache key file at ${keyPath}: ${parseError.message}`
+    );
+    try {
+      fs.unlinkSync(keyPath);
+    } catch {
+    }
+    if (createFileExclusively(keyPath, encoded)) return key;
+    return parseCacheKey(readFileSync(keyPath, "utf8"));
+  }
+}
+function createFileExclusively(filePath, contents) {
+  ensureParentDir(filePath);
+  const tempPath = tempPathFor(filePath);
+  try {
+    fs.writeFileSync(tempPath, contents, { mode: 384 });
+    fs.linkSync(tempPath, filePath);
+    return true;
+  } catch (error) {
+    if (error.code === "EEXIST") return false;
+    try {
+      fs.writeFileSync(filePath, contents, { mode: 384, flag: "wx" });
+      return fs.readFileSync(filePath, "utf8") === contents;
+    } catch (fallbackError) {
+      if (fallbackError.code === "EEXIST") return false;
+      throw fallbackError;
+    }
+  } finally {
+    try {
+      fs.unlinkSync(tempPath);
+    } catch {
+    }
+  }
+}
+function tempPathFor(filePath) {
+  return path.join(
+    path.dirname(filePath),
+    `.${path.basename(filePath)}.${randomBytes(8).toString("hex")}.tmp`
+  );
+}
+async function readCacheFile(key, cachePath) {
+  let onDisk;
+  try {
+    onDisk = readFileSync(cachePath, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT") return { status: "absent" };
+    return { status: "unreadable", reason: error.message };
+  }
+  if (onDisk === "") return { status: "absent" };
+  if (isEncryptedCache(onDisk)) {
+    const { keys } = await loadKeyState();
+    const decrypted = decryptWithAnyKey(onDisk, keys, key);
+    if (decrypted !== void 0) return { status: "decrypted", raw: decrypted };
+    keyStatePromise = void 0;
+    encryptionKeyPromise = void 0;
+    return { status: "unreadable", reason: "no known key opens it" };
+  }
+  if (isPlainCacheJson(onDisk)) return { status: "plaintext", raw: onDisk };
+  return { status: "unreadable", reason: "not a recognisable auth cache" };
+}
+function isPlainCacheJson(raw) {
+  try {
+    const parsed = JSON.parse(raw);
+    return parsed !== null && typeof parsed === "object";
+  } catch {
+    return false;
+  }
+}
+function decryptWithAnyKey(raw, keys, purpose) {
+  for (const key of keys) {
+    try {
+      return decryptCache(raw, key, purpose);
+    } catch {
+    }
+  }
+  return void 0;
+}
+async function assertOverwritable(key, cachePath) {
+  const state = await readCacheFile(key, cachePath);
+  if (state.status !== "unreadable") {
+    warnedUndecryptable.delete(key);
+    return;
+  }
+  if (!warnedUndecryptable.has(key)) {
+    warnedUndecryptable.add(key);
+    logger.warn(
+      `Not persisting ${key}: ${cachePath} cannot be read back (${state.reason}), and overwriting it would discard whatever it holds. A locked keychain usually reads fine on the next start. If it never does, delete ${cachePath} to start over.`
+    );
+  }
+  throw new Error(`Refusing to overwrite the unreadable auth cache at ${cachePath}`);
+}
 class DefaultTokenCacheStorage {
   constructor() {
-    this.description = "default (keytar+file)";
+    this.description = "default (encrypted file)";
     this.failClosed = false;
   }
   async load(key) {
     assertValidKey(key);
+    migrateLegacyPaths();
     let keytarRaw;
     try {
       const kt = await getKeytar();
       if (kt) {
         keytarRaw = await kt.getPassword(SERVICE_NAME, storageAccountForKey(key)) ?? void 0;
+        if (keytarRaw) legacyKeytarEntries.add(key);
       }
     } catch (error) {
       logger.warn(`Keychain access failed for ${key}: ${error.message}`);
     }
-    let fileRaw;
     const cachePath = filePathForKey(key);
-    if (existsSync(cachePath)) {
-      fileRaw = readFileSync(cachePath, "utf8");
+    const state = await readCacheFile(key, cachePath);
+    let fileRaw;
+    if (state.status === "decrypted" || state.status === "plaintext") {
+      fileRaw = state.raw;
+    } else if (state.status === "unreadable") {
+      logger.warn(
+        `Could not read ${key} back (${state.reason}); leaving it in place and re-authenticating`
+      );
     }
     return pickNewestRaw(keytarRaw, fileRaw);
   }
   async save(key, value) {
     assertValidKey(key);
-    try {
-      const kt = await getKeytar();
-      if (kt) {
-        await kt.setPassword(SERVICE_NAME, storageAccountForKey(key), value);
-        return;
-      }
-    } catch (error) {
-      logger.warn(
-        `Keychain save failed for ${key}, falling back to file storage: ${error.message}`
-      );
-    }
-    writeFileAtomically(filePathForKey(key), value);
+    migrateLegacyPaths();
+    const cachePath = filePathForKey(key);
+    await assertOverwritable(key, cachePath);
+    const encryptionKey = await getEncryptionKey();
+    await assertOverwritable(key, cachePath);
+    writeFileAtomically(cachePath, encryptCache(value, encryptionKey, key));
+    await clearLegacyKeytarEntry(key);
   }
   async delete(key) {
     assertValidKey(key);
@@ -331,9 +611,12 @@ export {
   CommandTokenCacheStorage,
   DefaultTokenCacheStorage,
   createTokenCacheStorage,
+  getCacheKeyPath,
   getSelectedAccountPath,
   getTokenCachePath,
+  migrateLegacyPathsFrom,
   pickNewest,
+  resetCacheKeyForTests,
   unwrapCache,
   wrapCache
 };

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "@softeria/ms-365-mcp-server",
-  "version": "0.137.0",
+  "mcpName": "io.github.Softeria/ms-365-mcp-server",
+  "version": "0.139.0",
   "description": " A Model Context Protocol (MCP) server for interacting with Microsoft 365 and Office services through the Graph API",
   "type": "module",
   "main": "dist/index.js",