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

package/src/graph-client.mjs

@@ -0,0 +1,293 @@
+import logger from './logger.mjs';
+
+class GraphClient {
+  constructor(authManager) {
+    this.authManager = authManager;
+    this.sessions = new Map();
+  }
+
+  async createSession(filePath) {
+    try {
+      if (!filePath) {
+        logger.error('No file path provided for Excel session');
+        return null;
+      }
+
+      if (this.sessions.has(filePath)) {
+        return this.sessions.get(filePath);
+      }
+
+      logger.info(`Creating new Excel session for file: ${filePath}`);
+      const accessToken = await this.authManager.getToken();
+
+      const response = await fetch(
+        `https://graph.microsoft.com/v1.0/me/drive/root:${filePath}:/workbook/createSession`,
+        {
+          method: 'POST',
+          headers: {
+            Authorization: `Bearer ${accessToken}`,
+            'Content-Type': 'application/json',
+          },
+          body: JSON.stringify({ persistChanges: true }),
+        }
+      );
+
+      if (!response.ok) {
+        const errorText = await response.text();
+        logger.error(`Failed to create session: ${response.status} - ${errorText}`);
+        return null;
+      }
+
+      const result = await response.json();
+      logger.info(`Session created successfully for file: ${filePath}`);
+
+      this.sessions.set(filePath, result.id);
+      return result.id;
+    } catch (error) {
+      logger.error(`Error creating Excel session: ${error}`);
+      return null;
+    }
+  }
+
+  async graphRequest(endpoint, options = {}) {
+    try {
+      let accessToken = await this.authManager.getToken();
+
+      let url;
+      let sessionId = null;
+
+      if (
+        options.excelFile &&
+        !endpoint.startsWith('/drive') &&
+        !endpoint.startsWith('/users') &&
+        !endpoint.startsWith('/me')
+      ) {
+        sessionId = this.sessions.get(options.excelFile);
+
+        if (!sessionId) {
+          sessionId = await this.createSession(options.excelFile);
+        }
+
+        url = `https://graph.microsoft.com/v1.0/me/drive/root:${options.excelFile}:${endpoint}`;
+      } else if (
+        endpoint.startsWith('/drive') ||
+        endpoint.startsWith('/users') ||
+        endpoint.startsWith('/me')
+      ) {
+        url = `https://graph.microsoft.com/v1.0${endpoint}`;
+      } else {
+        logger.error('Excel operation requested without specifying a file');
+        return {
+          content: [
+            {
+              type: 'text',
+              text: JSON.stringify({ error: 'No Excel file specified for this operation' }),
+            },
+          ],
+        };
+      }
+
+      const headers = {
+        Authorization: `Bearer ${accessToken}`,
+        'Content-Type': 'application/json',
+        ...(sessionId && { 'workbook-session-id': sessionId }),
+        ...options.headers,
+      };
+
+      const response = await fetch(url, {
+        headers,
+        ...options,
+      });
+
+      if (response.status === 401) {
+        logger.info('Access token expired, refreshing...');
+        const newToken = await this.authManager.getToken(true);
+
+        if (
+          options.excelFile &&
+          !endpoint.startsWith('/drive') &&
+          !endpoint.startsWith('/users') &&
+          !endpoint.startsWith('/me')
+        ) {
+          sessionId = await this.createSession(options.excelFile);
+        }
+
+        headers.Authorization = `Bearer ${newToken}`;
+        if (
+          sessionId &&
+          !endpoint.startsWith('/drive') &&
+          !endpoint.startsWith('/users') &&
+          !endpoint.startsWith('/me')
+        ) {
+          headers['workbook-session-id'] = sessionId;
+        }
+
+        const retryResponse = await fetch(url, {
+          headers,
+          ...options,
+        });
+
+        if (!retryResponse.ok) {
+          throw new Error(`Graph API error: ${retryResponse.status} ${await retryResponse.text()}`);
+        }
+
+        return this.formatResponse(retryResponse, options.rawResponse);
+      }
+
+      if (!response.ok) {
+        throw new Error(`Graph API error: ${response.status} ${await response.text()}`);
+      }
+
+      return this.formatResponse(response, options.rawResponse);
+    } catch (error) {
+      logger.error(`Error in Graph API request: ${error}`);
+      return {
+        content: [{ type: 'text', text: JSON.stringify({ error: error.message }) }],
+      };
+    }
+  }
+
+  async formatResponse(response, rawResponse = false) {
+    try {
+      if (response.status === 204) {
+        return {
+          content: [
+            {
+              type: 'text',
+              text: JSON.stringify({
+                message: 'Operation completed successfully',
+              }),
+            },
+          ],
+        };
+      }
+
+      if (rawResponse) {
+        const contentType = response.headers.get('content-type');
+
+        if (contentType && contentType.startsWith('text/')) {
+          const text = await response.text();
+          return {
+            content: [{ type: 'text', text }],
+          };
+        }
+
+        return {
+          content: [
+            {
+              type: 'text',
+              text: JSON.stringify({
+                message: 'Binary file content received',
+                contentType: contentType,
+                contentLength: response.headers.get('content-length'),
+              }),
+            },
+          ],
+        };
+      }
+
+      const result = await response.json();
+
+      const removeODataProps = (obj) => {
+        if (!obj || typeof obj !== 'object') return;
+
+        if (Array.isArray(obj)) {
+          obj.forEach((item) => removeODataProps(item));
+        } else {
+          Object.keys(obj).forEach((key) => {
+            if (key.startsWith('@odata')) {
+              delete obj[key];
+            } else if (typeof obj[key] === 'object') {
+              removeODataProps(obj[key]);
+            }
+          });
+        }
+      };
+
+      removeODataProps(result);
+
+      return {
+        content: [{ type: 'text', text: JSON.stringify(result) }],
+      };
+    } catch (error) {
+      logger.error(`Error formatting response: ${error}`);
+      return {
+        content: [{ type: 'text', text: JSON.stringify({ message: 'Success' }) }],
+      };
+    }
+  }
+
+  async closeSession(filePath) {
+    if (!filePath || !this.sessions.has(filePath)) {
+      return {
+        content: [
+          {
+            type: 'text',
+            text: JSON.stringify({ message: 'No active session for the specified file' }),
+          },
+        ],
+      };
+    }
+
+    const sessionId = this.sessions.get(filePath);
+
+    try {
+      const accessToken = await this.authManager.getToken();
+      const response = await fetch(
+        `https://graph.microsoft.com/v1.0/me/drive/root:${filePath}:/workbook/closeSession`,
+        {
+          method: 'POST',
+          headers: {
+            Authorization: `Bearer ${accessToken}`,
+            'Content-Type': 'application/json',
+            'workbook-session-id': sessionId,
+          },
+        }
+      );
+
+      if (response.ok) {
+        this.sessions.delete(filePath);
+        return {
+          content: [
+            {
+              type: 'text',
+              text: JSON.stringify({ message: `Session for ${filePath} closed successfully` }),
+            },
+          ],
+        };
+      } else {
+        throw new Error(`Failed to close session: ${response.status}`);
+      }
+    } catch (error) {
+      logger.error(`Error closing session: ${error}`);
+      return {
+        content: [
+          {
+            type: 'text',
+            text: JSON.stringify({ error: `Failed to close session for ${filePath}` }),
+          },
+        ],
+      };
+    }
+  }
+
+  async closeAllSessions() {
+    const results = [];
+
+    for (const [filePath, _] of this.sessions) {
+      const result = await this.closeSession(filePath);
+      results.push(result);
+    }
+
+    return {
+      content: [
+        {
+          type: 'text',
+          text: JSON.stringify({ message: 'All sessions closed', results }),
+        },
+      ],
+    };
+  }
+}
+
+export default GraphClient;

package/{logger.mjs → src/logger.mjs}

@@ -1,11 +1,10 @@
 import winston from 'winston';
 import path from 'path';
 import { fileURLToPath } from 'url';
+import fs from 'fs';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
-
-const logsDir = path.join(__dirname, 'logs');
-import fs from 'fs';
+const logsDir = path.join(__dirname, '..', 'logs');
 
 if (!fs.existsSync(logsDir)) {
   fs.mkdirSync(logsDir);

package/src/mail-tools.mjs

@@ -0,0 +1,159 @@
+import { z } from 'zod';
+
+export function registerMailTools(server, graphClient) {
+  server.tool(
+    'get-message',
+    {
+      messageId: z.string().describe('ID of the message to retrieve'),
+      select: z.array(z.string()).optional().describe('Properties to include in the response'),
+      expandAttachments: z
+        .boolean()
+        .optional()
+        .default(false)
+        .describe('Whether to include attachment details'),
+      expandMentions: z
+        .boolean()
+        .optional()
+        .default(false)
+        .describe('Whether to include @mention details'),
+      expandSingleValueExtendedProperties: z
+        .boolean()
+        .optional()
+        .default(false)
+        .describe('Whether to include single value extended properties'),
+      expandMultiValueExtendedProperties: z
+        .boolean()
+        .optional()
+        .default(false)
+        .describe('Whether to include multi-value extended properties'),
+    },
+    async ({
+      messageId,
+      select,
+      expandAttachments,
+      expandMentions,
+      expandSingleValueExtendedProperties,
+      expandMultiValueExtendedProperties,
+    }) => {
+      let endpoint = `/me/messages/${messageId}`;
+
+      const queryParams = [];
+
+      if (select && select.length > 0) {
+        queryParams.push(`$select=${select.join(',')}`);
+      }
+
+      const expandParams = [];
+
+      if (expandAttachments) {
+        expandParams.push('attachments');
+      }
+
+      if (expandMentions) {
+        expandParams.push('mentions');
+      }
+
+      if (expandSingleValueExtendedProperties) {
+        expandParams.push('singleValueExtendedProperties');
+      }
+
+      if (expandMultiValueExtendedProperties) {
+        expandParams.push('multiValueExtendedProperties');
+      }
+
+      if (expandParams.length > 0) {
+        queryParams.push(`$expand=${expandParams.join(',')}`);
+      }
+
+      if (queryParams.length > 0) {
+        endpoint += '?' + queryParams.join('&');
+      }
+
+      return graphClient.graphRequest(endpoint, {
+        method: 'GET',
+      });
+    }
+  );
+
+  server.tool(
+    'list-messages',
+    {
+      folderName: z
+        .string()
+        .optional()
+        .describe('Name of the folder to get messages from (e.g., "inbox", "drafts", "sentItems")'),
+      folderId: z
+        .string()
+        .optional()
+        .describe('ID of the folder to get messages from (instead of folderName)'),
+      filter: z.string().optional().describe('OData filter query (e.g., "isRead eq false")'),
+      select: z.array(z.string()).optional().describe('Properties to include in the response'),
+      top: z.number().optional().describe('Maximum number of messages to return'),
+      skip: z.number().optional().describe('Number of messages to skip'),
+      count: z
+        .boolean()
+        .optional()
+        .default(false)
+        .describe('Whether to include a count of the total number of messages'),
+      orderBy: z
+        .string()
+        .optional()
+        .describe('Property to sort by (e.g., "receivedDateTime desc")'),
+      search: z.string().optional().describe('Text to search for in messages'),
+    },
+    async ({ folderName, folderId, filter, select, top, skip, count, orderBy, search }) => {
+      let endpoint;
+
+      if (folderId) {
+        endpoint = `/me/mailFolders/${folderId}/messages`;
+      } else if (folderName) {
+        const standardFolderName = folderName.toLowerCase();
+        endpoint = `/me/mailFolders/${standardFolderName}/messages`;
+      } else {
+        endpoint = '/me/messages';
+      }
+
+      const queryParams = [];
+
+      if (filter) {
+        queryParams.push(`$filter=${encodeURIComponent(filter)}`);
+      }
+
+      if (select && select.length > 0) {
+        queryParams.push(`$select=${select.join(',')}`);
+      } else {
+        queryParams.push(
+          '$select=id,subject,receivedDateTime,from,isRead,importance,hasAttachments'
+        );
+      }
+
+      if (top) {
+        queryParams.push(`$top=${top}`);
+      }
+
+      if (skip) {
+        queryParams.push(`$skip=${skip}`);
+      }
+
+      if (count) {
+        queryParams.push('$count=true');
+      }
+
+      if (orderBy) {
+        queryParams.push(`$orderBy=${encodeURIComponent(orderBy)}`);
+      }
+
+      if (search) {
+        queryParams.push(`$search="${encodeURIComponent(search)}"`);
+      }
+
+      if (queryParams.length > 0) {
+        endpoint += '?' + queryParams.join('&');
+      }
+
+      return graphClient.graphRequest(endpoint, {
+        method: 'GET',
+      });
+    }
+  );
+}

package/src/server.mjs

@@ -0,0 +1,45 @@
+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 GraphClient from './graph-client.mjs';
+
+class MicrosoftGraphServer {
+  constructor(authManager, options = {}) {
+    this.authManager = authManager;
+    this.options = options;
+    this.graphClient = new GraphClient(authManager);
+    this.server = null;
+  }
+
+  async initialize(version) {
+    this.server = new McpServer({
+      name: 'Microsoft365MCP',
+      version,
+    });
+
+    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);
+  }
+
+  async start() {
+    if (this.options.v) {
+      enableConsoleLogging();
+    }
+
+    logger.info('Microsoft 365 MCP Server starting...');
+
+    const transport = new StdioServerTransport();
+    await this.server.connect(transport);
+    logger.info('Server connected to transport');
+  }
+}
+
+export default MicrosoftGraphServer;

package/src/version.mjs

@@ -0,0 +1,9 @@
+import { readFileSync } from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const packageJsonPath = path.join(__dirname, '..', 'package.json');
+const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf8'));
+
+export const version = packageJson.version;

package/test/cli.test.js

@@ -1,4 +1,6 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { parseArgs } from '../src/cli.mjs';
+
 vi.mock('commander', () => {
   const mockCommand = {
     name: vi.fn().mockReturnThis(),
@@ -24,9 +26,6 @@ vi.mock('../auth.mjs', () => {
 });
 vi.spyOn(process.stderr, 'write').mockImplementation(() => true);
 const mockExit = vi.spyOn(process, 'exit').mockImplementation(() => {});
-import { Command } from 'commander';
-import AuthManager from '../auth.mjs';
-import { parseArgs } from '../cli.mjs';
 
 describe('CLI Module', () => {
   beforeEach(() => {

package/test/graph-api.test.js

@@ -1,4 +1,5 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
 global.fetch = vi.fn();
 
 describe('Graph API Functions', () => {

package/test/mcp-server.test.js

@@ -1,5 +1,6 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
 import { z } from 'zod';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 
 vi.mock('@modelcontextprotocol/sdk/server/mcp.js', () => ({
   McpServer: vi.fn(() => ({
@@ -11,8 +12,6 @@ vi.mock('@modelcontextprotocol/sdk/server/mcp.js', () => ({
 }));
 vi.spyOn(process.stderr, 'write').mockImplementation(() => true);
 
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-
 describe('MCP Server', () => {
   let server;
 

package/test/integration.test.js

@@ -1,40 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-import path from 'path';
-import fs from 'fs';
-
-describe('Integration Tests', () => {
-  it('should have correct package.json configuration', () => {
-    const packagePath = path.resolve(process.cwd(), 'package.json');
-    const packageJson = JSON.parse(fs.readFileSync(packagePath, 'utf8'));
-
-    expect(packageJson).toHaveProperty('type', 'module');
-    expect(packageJson).toHaveProperty('bin.ms-365-mcp-server');
-    expect(packageJson.bin['ms-365-mcp-server']).toEqual('index.mjs');
-  });
-
-  it('should have all required dependencies', () => {
-    const packagePath = path.resolve(process.cwd(), 'package.json');
-    const packageJson = JSON.parse(fs.readFileSync(packagePath, 'utf8'));
-
-    const requiredDependencies = [
-      '@azure/msal-node',
-      '@modelcontextprotocol/sdk',
-      'commander',
-      'keytar',
-      'zod',
-    ];
-
-    requiredDependencies.forEach((dep) => {
-      expect(packageJson.dependencies).toHaveProperty(dep);
-    });
-  });
-
-  it('should have all required files', () => {
-    const requiredFiles = ['index.mjs', 'auth.mjs', 'cli.mjs', 'package.json', 'README.md'];
-
-    requiredFiles.forEach((file) => {
-      const filePath = path.resolve(process.cwd(), file);
-      expect(fs.existsSync(filePath)).toBe(true);
-    });
-  });
-});

package/test/simple.test.js

@@ -1,7 +0,0 @@
-import { describe, it, expect } from 'vitest';
-
-describe('Simple Test Suite', () => {
-  it('should pass a basic test', () => {
-    expect(1 + 1).toBe(2);
-  });
-});