@softeria/ms-365-mcp-server 0.10.1 → 0.11.0

package/dist/auth.js

@@ -141,8 +141,9 @@ class AuthManager {
         };
         try {
             logger.info('Requesting device code...');
-            logger.info(`Scopes are: ${this.scopes.join(', ')}`);
+            logger.info(`Requesting scopes: ${this.scopes.join(', ')}`);
             const response = await this.msalApp.acquireTokenByDeviceCode(deviceCodeRequest);
+            logger.info(`Granted scopes: ${response?.scopes?.join(', ') || 'none'}`);
             logger.info('Device code login successful');
             this.accessToken = response?.accessToken || null;
             this.tokenExpiry = response?.expiresOn ? new Date(response.expiresOn).getTime() : null;

package/dist/graph-client.js

@@ -47,7 +47,7 @@ class GraphClient {
     }
     async makeRequest(endpoint, options = {}) {
         // Use OAuth tokens if available, otherwise fall back to authManager
-        let accessToken = options.accessToken || this.accessToken || await this.authManager.getToken();
+        let accessToken = options.accessToken || this.accessToken || (await this.authManager.getToken());
         let refreshToken = options.refreshToken || this.refreshToken;
         if (!accessToken) {
             throw new Error('No access token available');
@@ -65,6 +65,24 @@ class GraphClient {
                 // Retry the request with new token
                 return this.performRequest(endpoint, accessToken, options);
             }
+            if (response.status === 403) {
+                const errorText = await response.text();
+                if (errorText.includes('scope') || errorText.includes('permission')) {
+                    const hasWorkPermissions = await this.authManager.hasWorkAccountPermissions();
+                    if (!hasWorkPermissions) {
+                        logger.info('403 scope error detected, attempting to expand to work account scopes...');
+                        const expanded = await this.authManager.expandToWorkAccountScopes();
+                        if (expanded) {
+                            const newToken = await this.authManager.getToken();
+                            if (newToken) {
+                                logger.info('Retrying request with expanded scopes...');
+                                return this.performRequest(endpoint, newToken, options);
+                            }
+                        }
+                    }
+                }
+                throw new Error(`Microsoft Graph API scope error: ${response.status} ${response.statusText} - ${errorText}`);
+            }
             if (!response.ok) {
                 throw new Error(`Microsoft Graph API error: ${response.status} ${response.statusText}`);
             }
@@ -116,7 +134,7 @@ class GraphClient {
             throw new Error('Excel operation requested without specifying a file');
         }
         const headers = {
-            'Authorization': `Bearer ${accessToken}`,
+            Authorization: `Bearer ${accessToken}`,
             'Content-Type': 'application/json',
             ...(sessionId && { 'workbook-session-id': sessionId }),
             ...options.headers,

package/dist/index.js

@@ -9,7 +9,17 @@ import { buildScopesFromEndpoints } from './auth.js';
 async function main() {
     try {
         const args = parseArgs();
-        const scopes = buildScopesFromEndpoints(args.forceWorkScopes);
+        let includeWorkScopes = args.forceWorkScopes;
+        if (!includeWorkScopes) {
+            const tempAuthManager = new AuthManager(undefined, buildScopesFromEndpoints(false));
+            await tempAuthManager.loadTokenCache();
+            const hasWorkPermissions = await tempAuthManager.hasWorkAccountPermissions();
+            if (hasWorkPermissions) {
+                includeWorkScopes = true;
+                logger.info('Detected existing work account permissions, including work scopes');
+            }
+        }
+        const scopes = buildScopesFromEndpoints(includeWorkScopes);
         const authManager = new AuthManager(undefined, scopes);
         await authManager.loadTokenCache();
         if (args.login) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@softeria/ms-365-mcp-server",
-  "version": "0.10.1",
+  "version": "0.11.0",
   "description": "Microsoft 365 MCP Server",
   "type": "module",
   "main": "dist/index.js",

package/remove-recursive-refs.js

@@ -0,0 +1,294 @@
+#!/usr/bin/env node
+
+import fs from 'fs';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+/**
+ * Detect if a schema definition creates recursive references
+ * Handles complex recursive paths like #/definitions/X/properties/body/anyOf/1
+ *
+ * I really really hope this solves
+ * https://github.com/Softeria/ms-365-mcp-server/issues/36 and perhaps even
+ * https://github.com/Softeria/ms-365-mcp-server/issues/62
+ *
+ * Or any other silly tool that doesn't support recursive $refs
+ *
+ * Note - if the tool still struggles with $ref in general, this fix won't help!
+ */
+function detectRecursiveRefs(schema, definitionName) {
+  if (!schema || typeof schema !== 'object') return [];
+
+  const recursions = [];
+  const currentDefPath = `#/definitions/${definitionName}`;
+
+  function findAllRefs(obj, path = []) {
+    const refs = [];
+
+    function traverse(current, currentPath) {
+      if (!current || typeof current !== 'object') return;
+
+      if (Array.isArray(current)) {
+        current.forEach((item, index) => traverse(item, [...currentPath, index]));
+        return;
+      }
+
+      if (current.$ref) {
+        refs.push({
+          ref: current.$ref,
+          path: currentPath.join('.'),
+        });
+        return;
+      }
+
+      Object.entries(current).forEach(([key, value]) => {
+        traverse(value, [...currentPath, key]);
+      });
+    }
+
+    traverse(obj, path);
+    return refs;
+  }
+
+  const allRefs = findAllRefs(schema);
+
+  for (const refInfo of allRefs) {
+    const ref = refInfo.ref;
+
+    if (ref.startsWith(currentDefPath)) {
+      recursions.push({
+        path: refInfo.path,
+        ref: ref,
+        type: 'recursive_reference',
+      });
+    } else if (ref === currentDefPath) {
+      recursions.push({
+        path: refInfo.path,
+        ref: ref,
+        type: 'direct_self_reference',
+      });
+    }
+  }
+
+  return recursions;
+}
+
+function removeRecursiveProperties(schema, recursions) {
+  if (!schema || typeof schema !== 'object' || recursions.length === 0) {
+    return schema;
+  }
+
+  const cleaned = JSON.parse(JSON.stringify(schema));
+
+  const propertiesToRemove = new Set();
+
+  for (const recursion of recursions) {
+    const pathParts = recursion.path.split('.').filter((p) => p !== '');
+
+    if (pathParts[pathParts.length - 1] === 'items' && pathParts.length > 1) {
+      const propertyPath = pathParts.slice(0, -1).join('.');
+      propertiesToRemove.add(propertyPath);
+    } else {
+      propertiesToRemove.add(recursion.path);
+    }
+  }
+
+  const sortedPaths = Array.from(propertiesToRemove).sort(
+    (a, b) => b.split('.').length - a.split('.').length
+  );
+
+  for (const propertyPath of sortedPaths) {
+    const pathParts = propertyPath.split('.');
+
+    let current = cleaned;
+    for (let i = 0; i < pathParts.length - 1; i++) {
+      const part = pathParts[i];
+      if (current && typeof current === 'object' && part in current) {
+        current = current[part];
+      } else {
+        current = null;
+        break;
+      }
+    }
+
+    if (current && typeof current === 'object') {
+      const propertyName = pathParts[pathParts.length - 1];
+      if (propertyName in current) {
+        console.log(`  Removing recursive property: ${propertyPath}`);
+        delete current[propertyName];
+      }
+    }
+  }
+
+  return cleaned;
+}
+
+/**
+ * Process a tool to remove recursive references while keeping other $refs
+ */
+function processToolSchema(tool) {
+  if (!tool.inputSchema || !tool.inputSchema.definitions) {
+    return tool;
+  }
+
+  const definitions = tool.inputSchema.definitions;
+  const processedDefinitions = {};
+  let totalRecursionsRemoved = 0;
+
+  console.log(`\n🔧 Processing ${tool.name}:`);
+
+  for (const [defName, defSchema] of Object.entries(definitions)) {
+    const recursions = detectRecursiveRefs(defSchema, defName);
+
+    if (recursions.length > 0) {
+      console.log(`  Found ${recursions.length} recursive references in ${defName}`);
+      processedDefinitions[defName] = removeRecursiveProperties(defSchema, recursions);
+      totalRecursionsRemoved += recursions.length;
+    } else {
+      processedDefinitions[defName] = defSchema;
+    }
+  }
+
+  const cleanedTool = {
+    ...tool,
+    inputSchema: {
+      ...tool.inputSchema,
+      definitions: processedDefinitions,
+    },
+  };
+
+  console.log(`  ✂️  Removed ${totalRecursionsRemoved} recursive references`);
+  return cleanedTool;
+}
+
+async function removeRecursiveRefs() {
+  try {
+    console.log('✂️  Removing Recursive References (Keeping Other $refs)\n');
+    console.log('='.repeat(60));
+
+    const inputPath = join(__dirname, 'schemas-with-refs-direct.json');
+    if (!fs.existsSync(inputPath)) {
+      throw new Error('Schema file not found. Run extract-schemas-direct.js first.');
+    }
+
+    const originalData = JSON.parse(fs.readFileSync(inputPath, 'utf8'));
+    const tools = originalData.result?.tools || [];
+
+    console.log(`Processing ${tools.length} tools...`);
+
+    const processedTools = tools.map(processToolSchema);
+
+    const cleanedData = {
+      ...originalData,
+      result: {
+        ...originalData.result,
+        tools: processedTools,
+      },
+    };
+
+    const outputPath = join(__dirname, 'schemas-properties-removed.json');
+    const cleanedString = JSON.stringify(cleanedData, null, 2);
+    fs.writeFileSync(outputPath, cleanedString);
+
+    console.log(`\n💾 Cleaned schemas saved to: ${outputPath}`);
+
+    const originalString = JSON.stringify(originalData);
+    const originalRefs = (originalString.match(/\$ref/g) || []).length;
+    const cleanedRefs = (cleanedString.match(/\$ref/g) || []).length;
+    const removedRefs = originalRefs - cleanedRefs;
+
+    console.log('\n📊 CLEANING ANALYSIS');
+    console.log('-'.repeat(40));
+    console.log(
+      `Original size:     ${originalString.length.toLocaleString()} chars (${(originalString.length / 1024).toFixed(2)} KB)`
+    );
+    console.log(
+      `Cleaned size:      ${cleanedString.length.toLocaleString()} chars (${(cleanedString.length / 1024).toFixed(2)} KB)`
+    );
+
+    const sizeDiff = cleanedString.length - originalString.length;
+    const sizeChange = ((sizeDiff / originalString.length) * 100).toFixed(1);
+    console.log(`Size change:       ${sizeDiff.toLocaleString()} chars (${sizeChange}%)`);
+
+    console.log(`\nOriginal $refs:    ${originalRefs}`);
+    console.log(`Cleaned $refs:     ${cleanedRefs}`);
+    console.log(`Removed $refs:     ${removedRefs}`);
+    console.log(`Refs remaining:    ${((cleanedRefs / originalRefs) * 100).toFixed(1)}%`);
+
+    console.log('\n🧪 QUICK RECURSION CHECK');
+    console.log('-'.repeat(40));
+
+    const sampleRecursiveTools = [
+      'create-calendar-event',
+      'update-calendar-event',
+      'create-onenote-page',
+    ];
+    let foundRecursions = 0;
+
+    for (const toolName of sampleRecursiveTools) {
+      const tool = processedTools.find((t) => t.name === toolName);
+      if (tool) {
+        const toolString = JSON.stringify(tool);
+        const recursivePattern = `#/definitions/${toolName}Parameters/properties/body/anyOf/1`;
+        if (toolString.includes(recursivePattern)) {
+          foundRecursions++;
+          console.log(`  ❌ ${toolName}: Still contains recursive pattern`);
+        } else {
+          console.log(`  ✅ ${toolName}: Recursive pattern removed`);
+        }
+      }
+    }
+
+    if (foundRecursions === 0) {
+      console.log('\n✅ No recursive patterns found in sample tools!');
+    } else {
+      console.log(`\n⚠️  ${foundRecursions} tools still contain recursive patterns`);
+    }
+
+    console.log('\n💡 SUMMARY');
+    console.log('='.repeat(40));
+
+    if (removedRefs > 0) {
+      console.log(`✅ Successfully removed ${removedRefs} recursive references`);
+      console.log(`✅ Kept ${cleanedRefs} non-recursive $ref references`);
+
+      if (sizeDiff < 0) {
+        console.log(`✅ Reduced schema size by ${Math.abs(sizeDiff).toLocaleString()} characters`);
+      } else if (sizeDiff < originalString.length * 0.1) {
+        console.log(`✅ Minimal size increase (${sizeChange}%)`);
+      }
+
+      console.log('\n📋 BENEFITS:');
+      console.log('• Eliminates infinite recursion during flattening');
+      console.log('• Preserves beneficial $ref references for shared types');
+      console.log('• May allow partial flattening for LangChain compatibility');
+      console.log('• Reduces schema complexity while maintaining functionality');
+    } else {
+      console.log('ℹ️  No recursive references found to remove');
+    }
+
+    const remainingRefTypes = new Set();
+    cleanedString.match(/"#\/definitions\/[^"]+"/g)?.forEach((ref) => {
+      const defName = ref.split('/').pop()?.replace('"', '');
+      if (defName) remainingRefTypes.add(defName);
+    });
+
+    console.log(`\n🔗 Remaining reference types: ${remainingRefTypes.size}`);
+    if (remainingRefTypes.size <= 10) {
+      console.log('Sample remaining refs:', Array.from(remainingRefTypes).slice(0, 5).join(', '));
+    }
+  } catch (error) {
+    console.error('Error removing recursive refs:', error.message);
+    console.error(error.stack);
+    process.exit(1);
+  }
+}
+
+export { removeRecursiveRefs };
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+  removeRecursiveRefs();
+}