ms365-mcp-server 1.1.20 → 1.1.22

package/dist/index.js

@@ -975,7 +975,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                         const currentUser = await enhancedMS365Auth.getCurrentUser();
                         const storageInfo = enhancedMS365Auth.getStorageInfo();
                         const tokenInfo = await enhancedMS365Auth.getTokenExpirationInfo();
-                        let statusText = `📊 Microsoft 365 Authentication Status\n\n🔐 Authentication: ${isAuthenticated ? '✅ Valid' : '❌ Not authenticated'}\n👤 Current User: ${currentUser || 'None'}\n💾 Storage method: ${storageInfo.method}\n📁 Storage location: ${storageInfo.location}`;
+                        let statusText = `📊 Microsoft 365 Authentication Status\n\n🔐 Authentication: ${isAuthenticated ? '✅ Valid' : '❌ Not authenticated'}\n👤 Current User: ${currentUser || 'None'}\n`;
                         if (isAuthenticated) {
                             statusText += `\n⏰ Token expires in: ${tokenInfo.expiresInMinutes} minutes`;
                             if (tokenInfo.needsRefresh) {

package/dist/utils/credential-store.js

@@ -1,57 +1,65 @@
 import * as fs from 'fs';
 import * as path from 'path';
-import * as os from 'os';
 import { logger } from './api.js';
+import { getConfigDirWithFallback } from './config-dir.js';
 // Service name for keychain storage
 const SERVICE_NAME = 'ms365-mcp-server';
-// Fallback directory for file-based storage
-const FALLBACK_DIR = path.join(os.homedir(), '.ms365-mcp');
+// Directory for file-based storage (now primary storage method)
+const STORAGE_DIR = getConfigDirWithFallback();
 /**
- * Secure credential store that uses OS keychain when available,
- * with encrypted file fallback for cross-platform compatibility.
+ * Secure credential store that uses file-based storage as default,
+ * with optional OS keychain support if specifically enabled.
  */
 export class CredentialStore {
     constructor() {
         this.useKeychain = false;
         this.keytar = null;
-        this.initialized = false;
-        this.initPromise = null;
-        this.ensureFallbackDir();
-        this.initPromise = this.initializeKeychain();
+        this.initialized = true; // File storage is always ready
+        this.forceFileStorage = true; // Force file storage as default
+        this.ensureStorageDir();
+        // Don't initialize keychain by default - file storage is primary
+        logger.log('Using file-based credential storage as default');
     }
     /**
      * Ensure the credential store is initialized
      */
     async ensureInitialized() {
-        if (!this.initialized && this.initPromise) {
-            await this.initPromise;
-            this.initialized = true;
-        }
+        // File storage is always ready, no async initialization needed
+        return;
     }
     /**
-     * Initialize keychain support if available
+     * Enable keychain support (optional)
      */
-    async initializeKeychain() {
+    async enableKeychain() {
         try {
             // Try to load keytar for secure OS keychain storage
             // Use eval to prevent TypeScript from checking the import at compile time
             const keytarModule = await eval('import("keytar")');
             this.keytar = keytarModule.default || keytarModule;
             this.useKeychain = true;
+            this.forceFileStorage = false;
             logger.log('OS keychain support enabled');
+            return true;
         }
         catch (error) {
-            // Keytar might not be available on all systems
-            logger.log('OS keychain not available, using file fallback');
-            this.useKeychain = false;
+            logger.log('OS keychain not available, continuing with file storage');
+            return false;
         }
     }
     /**
-     * Ensure fallback directory exists
+     * Force file storage (disable keychain)
+     */
+    forceFileStorageMode() {
+        this.useKeychain = false;
+        this.forceFileStorage = true;
+        logger.log('Forced file storage mode enabled');
+    }
+    /**
+     * Ensure storage directory exists
      */
-    ensureFallbackDir() {
-        if (!fs.existsSync(FALLBACK_DIR)) {
-            fs.mkdirSync(FALLBACK_DIR, { recursive: true });
+    ensureStorageDir() {
+        if (!fs.existsSync(STORAGE_DIR)) {
+            fs.mkdirSync(STORAGE_DIR, { recursive: true });
         }
     }
     /**
@@ -59,27 +67,35 @@ export class CredentialStore {
      */
     async setCredentials(account, credentials) {
         await this.ensureInitialized();
+        // Always use file storage as primary method
+        if (this.forceFileStorage || !this.useKeychain || !this.keytar) {
+            await this.setCredentialsFile(account, credentials);
+            return;
+        }
+        // Only use keychain if explicitly enabled and file storage is disabled
         const credentialString = JSON.stringify(credentials);
-        if (this.useKeychain && this.keytar) {
-            try {
-                await this.keytar.setPassword(SERVICE_NAME, account, credentialString);
-                logger.log(`Stored credentials for ${account} in OS keychain`);
-                return;
-            }
-            catch (error) {
-                logger.error(`Failed to store in keychain for ${account}:`, error);
-                // Fall through to file storage
-            }
+        try {
+            await this.keytar.setPassword(SERVICE_NAME, account, credentialString);
+            logger.log(`Stored credentials for ${account} in OS keychain`);
+        }
+        catch (error) {
+            logger.error(`Failed to store in keychain for ${account}:`, error);
+            // Fall back to file storage
+            await this.setCredentialsFile(account, credentials);
         }
-        // Fallback to file storage
-        await this.setCredentialsFile(account, credentials);
     }
     /**
      * Retrieve credentials securely
      */
     async getCredentials(account) {
         await this.ensureInitialized();
-        if (this.useKeychain && this.keytar) {
+        // Always try file storage first
+        const fileCredentials = await this.getCredentialsFile(account);
+        if (fileCredentials) {
+            return fileCredentials;
+        }
+        // Only check keychain if file storage failed and keychain is enabled
+        if (!this.forceFileStorage && this.useKeychain && this.keytar) {
             try {
                 const credentialString = await this.keytar.getPassword(SERVICE_NAME, account);
                 if (credentialString) {
@@ -89,11 +105,9 @@ export class CredentialStore {
             }
             catch (error) {
                 logger.error(`Failed to retrieve from keychain for ${account}:`, error);
-                // Fall through to file storage
             }
         }
-        // Fallback to file storage
-        return await this.getCredentialsFile(account);
+        return null;
     }
     /**
      * Delete credentials securely
@@ -138,11 +152,11 @@ export class CredentialStore {
         return Array.from(accounts);
     }
     /**
-     * File-based credential storage (fallback)
+     * File-based credential storage (primary method)
      */
     async setCredentialsFile(account, credentials) {
         try {
-            const filePath = path.join(FALLBACK_DIR, `token_${this.sanitizeFilename(account)}.json`);
+            const filePath = path.join(STORAGE_DIR, `token_${this.sanitizeFilename(account)}.json`);
             const encryptedData = this.simpleEncrypt(JSON.stringify(credentials));
             fs.writeFileSync(filePath, encryptedData);
             logger.log(`Stored credentials for ${account} in file`);
@@ -153,11 +167,11 @@ export class CredentialStore {
         }
     }
     /**
-     * File-based credential retrieval (fallback)
+     * File-based credential retrieval (primary method)
      */
     async getCredentialsFile(account) {
         try {
-            const filePath = path.join(FALLBACK_DIR, `token_${this.sanitizeFilename(account)}.json`);
+            const filePath = path.join(STORAGE_DIR, `token_${this.sanitizeFilename(account)}.json`);
             if (!fs.existsSync(filePath)) {
                 return null;
             }
@@ -172,11 +186,11 @@ export class CredentialStore {
         }
     }
     /**
-     * File-based credential deletion (fallback)
+     * File-based credential deletion (primary method)
      */
     async deleteCredentialsFile(account) {
         try {
-            const filePath = path.join(FALLBACK_DIR, `token_${this.sanitizeFilename(account)}.json`);
+            const filePath = path.join(STORAGE_DIR, `token_${this.sanitizeFilename(account)}.json`);
             if (fs.existsSync(filePath)) {
                 fs.unlinkSync(filePath);
                 logger.log(`Deleted credentials for ${account} from file`);
@@ -194,7 +208,7 @@ export class CredentialStore {
      */
     async listFileAccounts() {
         try {
-            const files = fs.readdirSync(FALLBACK_DIR);
+            const files = fs.readdirSync(STORAGE_DIR);
             return files
                 .filter(file => file.startsWith('token_') && file.endsWith('.json'))
                 .map(file => file.replace('token_', '').replace('.json', ''))
@@ -246,13 +260,22 @@ export class CredentialStore {
      * Check if keychain is available
      */
     isKeychainAvailable() {
-        return this.useKeychain && this.keytar !== null;
+        return this.useKeychain && this.keytar !== null && !this.forceFileStorage;
     }
     /**
      * Get storage method being used
      */
     getStorageMethod() {
-        return this.useKeychain ? 'OS Keychain' : 'Encrypted File';
+        if (this.forceFileStorage || !this.useKeychain || !this.keytar) {
+            return 'Encrypted File';
+        }
+        return 'OS Keychain';
+    }
+    /**
+     * Get storage location
+     */
+    getStorageLocation() {
+        return STORAGE_DIR;
     }
 }
 export const credentialStore = new CredentialStore();

package/dist/utils/ms365-auth-enhanced.js

@@ -835,7 +835,7 @@ export class EnhancedMS365Auth {
     getStorageInfo() {
         return {
             method: credentialStore.getStorageMethod(),
-            location: credentialStore.isKeychainAvailable() ? 'OS Keychain' : CONFIG_DIR
+            location: credentialStore.getStorageLocation()
         };
     }
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ms365-mcp-server",
-  "version": "1.1.20",
+  "version": "1.1.22",
   "description": "Microsoft 365 MCP Server for managing Microsoft 365 email through natural language interactions with full OAuth2 authentication support",
   "main": "dist/index.js",
   "type": "module",