@softeria/ms-365-mcp-server 0.2.2 → 0.3.1

package/src/dynamic-tools.mjs

@@ -0,0 +1,231 @@
+import logger from './logger.mjs';
+import {
+  buildParameterSchemas,
+  buildRequestUrl,
+  findPathAndOperation,
+  isMethodWithBody,
+  loadOpenApiSpec,
+} from './openapi-helpers.mjs';
+
+export const TARGET_ENDPOINTS = [
+  {
+    pathPattern: '/me/messages',
+    method: 'get',
+    toolName: 'list-mail-messages',
+  },
+  {
+    pathPattern: '/me/mailFolders',
+    method: 'get',
+    toolName: 'list-mail-folders',
+  },
+  {
+    pathPattern: '/me/mailFolders/{mailFolder-id}/messages',
+    method: 'get',
+    toolName: 'list-mail-folder-messages',
+  },
+  {
+    pathPattern: '/me/messages/{message-id}',
+    method: 'get',
+    toolName: 'get-mail-message',
+  },
+  {
+    pathPattern: '/me/events',
+    method: 'get',
+    toolName: 'list-calendar-events',
+  },
+  {
+    pathPattern: '/me/events/{event-id}',
+    method: 'get',
+    toolName: 'get-calendar-event',
+  },
+  {
+    pathPattern: '/me/events',
+    method: 'post',
+    toolName: 'create-calendar-event',
+  },
+  {
+    pathPattern: '/me/events/{event-id}',
+    method: 'patch',
+    toolName: 'update-calendar-event',
+  },
+  {
+    pathPattern: '/me/events/{event-id}',
+    method: 'delete',
+    toolName: 'delete-calendar-event',
+  },
+  {
+    pathPattern: '/me/calendarView',
+    method: 'get',
+    toolName: 'get-calendar-view',
+  },
+  {
+    pathPattern: '/users/{user-id}/drive',
+    method: 'get',
+    toolName: 'get-user-drive',
+  },
+  {
+    pathPattern: '/drives',
+    method: 'get',
+    toolName: 'list-drives',
+  },
+  {
+    pathPattern: '/drives/{drive-id}/root',
+    method: 'get',
+    toolName: 'get-drive-root-item',
+  },
+  {
+    pathPattern: '/drives/{drive-id}/root',
+    method: 'get',
+    toolName: 'get-root-folder',
+  },
+  {
+    pathPattern: '/drives/{drive-id}/items/{driveItem-id}/children',
+    method: 'get',
+    toolName: 'list-folder-files',
+  },
+  {
+    pathPattern: '/drives/{drive-id}/items/{driveItem-id}/children',
+    method: 'post',
+    toolName: 'create-item-in-folder',
+  },
+  {
+    pathPattern: '/drives/{drive-id}/items/{driveItem-id}/children/{driveItem-id1}/content',
+    method: 'get',
+    toolName: 'download-file-content',
+  },
+  {
+    pathPattern: '/drives/{drive-id}/items/{driveItem-id}',
+    method: 'delete',
+    toolName: 'delete-file',
+  },
+  {
+    pathPattern: '/drives/{drive-id}/items/{driveItem-id}',
+    method: 'patch',
+    toolName: 'update-file-metadata',
+  },
+  {
+    pathPattern:
+      '/drives/{drive-id}/items/{driveItem-id}/workbook/worksheets/{workbookWorksheet-id}/charts/add',
+    method: 'post',
+    toolName: 'create-chart',
+    isExcelOp: true,
+  },
+  {
+    pathPattern:
+      '/drives/{drive-id}/items/{driveItem-id}/workbook/worksheets/{workbookWorksheet-id}/range()/format',
+    method: 'patch',
+    toolName: 'format-range',
+    isExcelOp: true,
+  },
+  {
+    pathPattern:
+      '/drives/{drive-id}/items/{driveItem-id}/workbook/worksheets/{workbookWorksheet-id}/range()/sort',
+    method: 'patch',
+    toolName: 'sort-range',
+    isExcelOp: true,
+  },
+  {
+    pathPattern:
+      "/drives/{drive-id}/items/{driveItem-id}/workbook/worksheets/{workbookWorksheet-id}/range(address='{address}')",
+    method: 'get',
+    toolName: 'get-range',
+    isExcelOp: true,
+  },
+  {
+    pathPattern: '/drives/{drive-id}/items/{driveItem-id}/workbook/worksheets',
+    method: 'get',
+    toolName: 'list-worksheets',
+    isExcelOp: true,
+  },
+];
+
+export async function registerDynamicTools(server, graphClient) {
+  try {
+    const openapi = loadOpenApiSpec();
+    logger.info('Generating dynamic tools from OpenAPI spec...');
+
+    for (const endpoint of TARGET_ENDPOINTS) {
+      const result = findPathAndOperation(openapi, endpoint.pathPattern, endpoint.method);
+      if (!result) continue;
+
+      const { operation } = result;
+
+      logger.info(
+        `Creating tool ${endpoint.toolName} for ${endpoint.method.toUpperCase()} ${endpoint.pathPattern}`
+      );
+
+      const paramsSchema = buildParameterSchemas(endpoint, operation);
+
+      if (endpoint.hasCustomParams) {
+        if (endpoint.toolName === 'upload-file') {
+          paramsSchema.content = z.string().describe('File content to upload');
+          paramsSchema.contentType = z
+            .string()
+            .optional()
+            .describe('Content type of the file (e.g., "application/pdf", "image/jpeg")');
+        } else if (endpoint.toolName === 'create-folder') {
+          paramsSchema.name = z.string().describe('Name of the folder to create');
+          paramsSchema.description = z.string().optional().describe('Description of the folder');
+        }
+      }
+
+      const pathParams = endpoint.pathPattern.match(/\{([^}]+)}/g) || [];
+
+      const handler = async (params) => {
+        if (endpoint.isExcelOp && !params.filePath) {
+          return {
+            content: [
+              {
+                type: 'text',
+                text: JSON.stringify({
+                  error: 'filePath parameter is required for Excel operations',
+                }),
+              },
+            ],
+          };
+        }
+
+        const options = {
+          method: endpoint.method.toUpperCase(),
+        };
+
+        if (endpoint.isExcelOp) {
+          options.excelFile = params.filePath;
+        }
+
+        if (endpoint.toolName === 'download-file') {
+          options.rawResponse = true;
+        }
+
+        const url = buildRequestUrl(endpoint.pathPattern, params, pathParams, operation.parameters);
+
+        if (endpoint.toolName === 'upload-file' && params.content) {
+          options.body = params.content;
+          options.headers = {
+            'Content-Type': params.contentType || 'application/octet-stream',
+          };
+        } else if (endpoint.toolName === 'create-folder' && params.name) {
+          options.body = JSON.stringify({
+            name: params.name,
+            folder: {},
+            '@microsoft.graph.conflictBehavior': 'rename',
+            ...(params.description && { description: params.description }),
+          });
+          options.headers = {
+            'Content-Type': 'application/json',
+          };
+        } else if (isMethodWithBody(endpoint.method.toLowerCase()) && params.body) {
+          options.body = JSON.stringify(params.body);
+        }
+
+        return graphClient.graphRequest(url, options);
+      };
+
+      server.tool(endpoint.toolName, paramsSchema, handler);
+    }
+    logger.info(`Dynamic tools registration complete.`);
+  } catch (error) {
+    logger.error('Error registering dynamic tools:', error);
+    throw error;
+  }
+}

package/src/openapi-helpers.mjs

@@ -0,0 +1,187 @@
+import fs from 'fs';
+import path from 'path';
+import yaml from 'js-yaml';
+import { fileURLToPath } from 'url';
+import { z } from 'zod';
+import logger from './logger.mjs';
+import { createFriendlyParamName, registerParamMapping } from './param-mapper.mjs';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+export const OPENAPI_PATH = path.join(__dirname, '..', 'openapi', 'openapi.yaml');
+
+export function loadOpenApiSpec() {
+  try {
+    logger.info('Loading OpenAPI spec...');
+    const openapiContent = fs.readFileSync(OPENAPI_PATH, 'utf8');
+    return yaml.load(openapiContent);
+  } catch (error) {
+    logger.error('Error loading OpenAPI spec:', error);
+    throw error;
+  }
+}
+
+export function mapToZodType(schema) {
+  if (!schema) return z.any();
+
+  if (schema.$ref) {
+    const refName = schema.$ref.split('/').pop();
+    if (refName.toLowerCase().includes('string')) return z.string();
+    if (refName.toLowerCase().includes('int') || refName.toLowerCase().includes('number'))
+      return z.number();
+    if (refName.toLowerCase().includes('boolean')) return z.boolean();
+    if (refName.toLowerCase().includes('date')) return z.string();
+    if (refName.toLowerCase().includes('object')) return z.object({}).passthrough();
+    if (refName.toLowerCase().includes('array')) return z.array(z.any());
+
+    return z.object({}).passthrough();
+  }
+
+  switch (schema.type) {
+    case 'string':
+      const stringSchema = z.string();
+      if (schema.format === 'date-time') return stringSchema;
+      if (schema.enum) return z.enum(schema.enum);
+      return stringSchema;
+    case 'integer':
+    case 'number':
+      return z.number();
+    case 'boolean':
+      return z.boolean();
+    case 'array':
+      return z.array(mapToZodType(schema.items || {}));
+    case 'object':
+      const properties = schema.properties || {};
+      const shape = {};
+
+      Object.entries(properties).forEach(([key, prop]) => {
+        shape[key] = mapToZodType(prop);
+        if (schema.required && schema.required.includes(key)) {
+        } else {
+          shape[key] = shape[key].optional();
+        }
+      });
+
+      return z.object(shape).passthrough();
+    default:
+      return z.any();
+  }
+}
+
+export function processParameter(parameter) {
+  const zodSchema = mapToZodType(parameter.schema);
+
+  let schema = parameter.description ? zodSchema.describe(parameter.description) : zodSchema;
+
+  if (!parameter.required) {
+    schema = schema.optional();
+  }
+
+  return schema;
+}
+
+export function findPathAndOperation(openapi, pathPattern, method) {
+  const path = openapi.paths[pathPattern];
+
+  if (!path) {
+    logger.warn(`Path ${pathPattern} not found in OpenAPI spec`);
+    return null;
+  }
+
+  const operation = path[method.toLowerCase()];
+
+  if (!operation) {
+    logger.warn(`Method ${method} not found for path ${pathPattern}`);
+    return null;
+  }
+
+  return { path, operation };
+}
+
+export function isMethodWithBody(method) {
+  return ['post', 'put', 'patch'].includes(method);
+}
+
+export function buildParameterSchemas(endpoint, operation) {
+  const paramsSchema = {};
+
+  const pathParams = endpoint.pathPattern.match(/\{([^}]+)}/g) || [];
+  pathParams.forEach((param) => {
+    const paramName = param.slice(1, -1);
+    paramsSchema[paramName] = z.string().describe(`Path parameter: ${paramName}`);
+  });
+
+  if (operation.parameters) {
+    operation.parameters.forEach((param) => {
+      if (param.in === 'query') {
+        if (!pathParams.includes(`{${param.name}}`)) {
+          const friendlyName = createFriendlyParamName(param.name);
+          registerParamMapping(endpoint.toolName, friendlyName, param.name);
+          paramsSchema[friendlyName] = processParameter(param);
+        }
+      }
+    });
+  }
+
+  if (isMethodWithBody(endpoint.method) && operation.requestBody) {
+    const contentType =
+      operation.requestBody.content?.['application/json'] ||
+      operation.requestBody.content?.['*/*'] ||
+      {};
+
+    if (contentType.schema) {
+      paramsSchema.body = z
+        .object({})
+        .passthrough()
+        .describe(operation.requestBody.description || 'Request body');
+    }
+  }
+
+  if (endpoint.isExcelOp) {
+    paramsSchema.filePath = z.string().describe('Path to the Excel file in OneDrive');
+
+    if (endpoint.pathPattern.includes('range(address=')) {
+      paramsSchema.address = z.string().describe('Excel range address (e.g., "A1:B10")');
+    }
+  }
+
+  return paramsSchema;
+}
+
+export function buildRequestUrl(baseUrl, params, pathParams, queryParamDefs) {
+  let url = baseUrl;
+
+  pathParams.forEach((param) => {
+    const paramName = param.slice(1, -1);
+    url = url.replace(param, params[paramName]);
+  });
+
+  if (url.includes("range(address='{address}')") && params.address) {
+    url = url.replace('{address}', encodeURIComponent(params.address));
+  }
+
+  const queryParams = [];
+
+  if (queryParamDefs) {
+    queryParamDefs.forEach((param) => {
+      if (param.in === 'query') {
+        const friendlyName = createFriendlyParamName(param.name);
+
+        if (params[friendlyName] !== undefined) {
+          if (Array.isArray(params[friendlyName])) {
+            queryParams.push(`${param.name}=${params[friendlyName].join(',')}`);
+          } else {
+            queryParams.push(`${param.name}=${encodeURIComponent(params[friendlyName])}`);
+          }
+        }
+      }
+    });
+  }
+
+  if (queryParams.length > 0) {
+    url += '?' + queryParams.join('&');
+  }
+
+  return url;
+}

package/src/param-mapper.mjs

@@ -0,0 +1,30 @@
+const paramMappings = new Map();
+
+export function createFriendlyParamName(originalName) {
+  if (originalName.startsWith('$')) {
+    return originalName.substring(1);
+  }
+  
+  return originalName;
+}
+
+export function registerParamMapping(toolName, friendlyName, originalName) {
+  const key = `${toolName}:${friendlyName}`;
+  paramMappings.set(key, originalName);
+}
+
+export function getOriginalParamName(toolName, friendlyName) {
+  const key = `${toolName}:${friendlyName}`;
+  return paramMappings.get(key) || friendlyName;
+}
+
+export function transformParamsToOriginal(toolName, params) {
+  const result = {};
+  
+  for (const [friendlyName, value] of Object.entries(params)) {
+    const originalName = getOriginalParamName(toolName, friendlyName);
+    result[originalName] = value;
+  }
+  
+  return result;
+}

package/src/server.mjs

@@ -1,11 +1,8 @@
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import logger, { enableConsoleLogging } from './logger.mjs';
-import { registerExcelTools } from './excel-tools.mjs';
 import { registerAuthTools } from './auth-tools.mjs';
-import { registerFilesTools } from './files-tools.mjs';
-import { registerCalendarTools } from './calendar-tools.mjs';
-import { registerMailTools } from './mail-tools.mjs';
+import { registerDynamicTools } from './dynamic-tools.mjs';
 import GraphClient from './graph-client.mjs';
 
 class MicrosoftGraphServer {
@@ -23,10 +20,7 @@ class MicrosoftGraphServer {
     });
 
     registerAuthTools(this.server, this.authManager);
-    registerFilesTools(this.server, this.graphClient);
-    registerExcelTools(this.server, this.graphClient);
-    registerCalendarTools(this.server, this.graphClient);
-    registerMailTools(this.server, this.graphClient);
+    await registerDynamicTools(this.server, this.graphClient);
   }
 
   async start() {

package/test/auth-tools.test.js

@@ -0,0 +1,94 @@
+import { describe, expect, it, vi, beforeEach } from 'vitest';
+
+// Mock Zod
+vi.mock('zod', () => {
+  const mockZod = {
+    boolean: () => ({
+      default: () => ({
+        describe: () => 'mocked-zod-boolean'
+      })
+    }),
+    object: () => ({
+      strict: () => 'mocked-zod-object'
+    })
+  };
+  return { z: mockZod };
+});
+
+import { registerAuthTools } from '../src/auth-tools.mjs';
+
+describe('Auth Tools', () => {
+  let server;
+  let authManager;
+  let loginTool;
+  
+  beforeEach(() => {
+    loginTool = vi.fn();
+    
+    server = {
+      tool: vi.fn((name, schema, handler) => {
+        if (name === 'login') {
+          loginTool = handler;
+        }
+      })
+    };
+    
+    authManager = {
+      testLogin: vi.fn(),
+      acquireTokenByDeviceCode: vi.fn()
+    };
+    
+    registerAuthTools(server, authManager);
+  });
+  
+  describe('login tool', () => {
+    it('should check if already logged in when force=false', async () => {
+      authManager.testLogin.mockResolvedValue({
+        success: true,
+        userData: { displayName: 'Test User' }
+      });
+      
+      const result = await loginTool({ force: false });
+      
+      expect(authManager.testLogin).toHaveBeenCalled();
+      expect(authManager.acquireTokenByDeviceCode).not.toHaveBeenCalled();
+      expect(result.content[0].text).toContain('Already logged in');
+    });
+    
+    it('should force login when force=true even if already logged in', async () => {
+      authManager.testLogin.mockResolvedValue({
+        success: true,
+        userData: { displayName: 'Test User' }
+      });
+      
+      authManager.acquireTokenByDeviceCode.mockImplementation(callback => {
+        callback('Login instructions');
+        return Promise.resolve();
+      });
+      
+      const result = await loginTool({ force: true });
+      
+      expect(authManager.testLogin).not.toHaveBeenCalled();
+      expect(authManager.acquireTokenByDeviceCode).toHaveBeenCalled();
+      expect(result.content[0].text).toBe('Login instructions');
+    });
+    
+    it('should proceed with login when not already logged in', async () => {
+      authManager.testLogin.mockResolvedValue({
+        success: false,
+        message: 'Not logged in'
+      });
+      
+      authManager.acquireTokenByDeviceCode.mockImplementation(callback => {
+        callback('Login instructions');
+        return Promise.resolve();
+      });
+      
+      const result = await loginTool({ force: false });
+      
+      expect(authManager.testLogin).toHaveBeenCalled();
+      expect(authManager.acquireTokenByDeviceCode).toHaveBeenCalled();
+      expect(result.content[0].text).toBe('Login instructions');
+    });
+  });
+});