@softeria/ms-365-mcp-server 0.4.1 → 0.4.3

package/src/graph-client.ts

@@ -1,328 +0,0 @@
-import logger from './logger.js';
-import AuthManager from './auth.js';
-
-interface GraphRequestOptions {
-  excelFile?: string;
-  headers?: Record<string, string>;
-  method?: string;
-  body?: string;
-  rawResponse?: boolean;
-
-  [key: string]: any;
-}
-
-interface ContentItem {
-  type: 'text';
-  text: string;
-
-  [key: string]: unknown;
-}
-
-interface McpResponse {
-  content: ContentItem[];
-  _meta?: Record<string, unknown>;
-  isError?: boolean;
-
-  [key: string]: unknown;
-}
-
-class GraphClient {
-  private authManager: AuthManager;
-  private sessions: Map<string, string>;
-
-  constructor(authManager: AuthManager) {
-    this.authManager = authManager;
-    this.sessions = new Map();
-  }
-
-  async createSession(filePath: string): Promise<string | null> {
-    try {
-      if (!filePath) {
-        logger.error('No file path provided for Excel session');
-        return null;
-      }
-
-      if (this.sessions.has(filePath)) {
-        return this.sessions.get(filePath) || null;
-      }
-
-      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: string, options: GraphRequestOptions = {}): Promise<McpResponse> {
-    try {
-      logger.info(`Calling ${endpoint} with options: ${JSON.stringify(options)}`);
-      let accessToken = await this.authManager.getToken();
-
-      let url: string;
-      let sessionId: string | null = null;
-
-      if (
-        options.excelFile &&
-        !endpoint.startsWith('/drive') &&
-        !endpoint.startsWith('/users') &&
-        !endpoint.startsWith('/me')
-      ) {
-        sessionId = this.sessions.get(options.excelFile) || null;
-
-        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: Record<string, string> = {
-        ...options.headers,
-        Authorization: `Bearer ${accessToken}`,
-        'Content-Type': 'application/json',
-        ...(sessionId && { 'workbook-session-id': sessionId }),
-      };
-      delete options.headers;
-
-      logger.info(` ** Making request to ${url} with options: ${JSON.stringify(options)}`);
-
-      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 as Error).message }) }],
-        isError: true,
-      };
-    }
-  }
-
-  async formatResponse(response: Response, rawResponse = false): Promise<McpResponse> {
-    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: any): void => {
-        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: string): Promise<McpResponse> {
-    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}` }),
-          },
-        ],
-        isError: true,
-      };
-    }
-  }
-
-  async closeAllSessions(): Promise<McpResponse> {
-    const results: McpResponse[] = [];
-
-    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/src/graph-tools.ts

@@ -1,174 +0,0 @@
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import logger from './logger.js';
-import GraphClient from './graph-client.js';
-import { api } from './generated/client.js';
-import { z } from 'zod';
-
-type TextContent = {
-  type: 'text';
-  text: string;
-  [key: string]: unknown;
-};
-
-type ImageContent = {
-  type: 'image';
-  data: string;
-  mimeType: string;
-  [key: string]: unknown;
-};
-
-type AudioContent = {
-  type: 'audio';
-  data: string;
-  mimeType: string;
-  [key: string]: unknown;
-};
-
-type ResourceTextContent = {
-  type: 'resource';
-  resource: {
-    text: string;
-    uri: string;
-    mimeType?: string;
-    [key: string]: unknown;
-  };
-  [key: string]: unknown;
-};
-
-type ResourceBlobContent = {
-  type: 'resource';
-  resource: {
-    blob: string;
-    uri: string;
-    mimeType?: string;
-    [key: string]: unknown;
-  };
-  [key: string]: unknown;
-};
-
-type ResourceContent = ResourceTextContent | ResourceBlobContent;
-
-type ContentItem = TextContent | ImageContent | AudioContent | ResourceContent;
-
-interface CallToolResult {
-  content: ContentItem[];
-  _meta?: Record<string, unknown>;
-  isError?: boolean;
-
-  [key: string]: unknown;
-}
-
-export function registerGraphTools(server: McpServer, graphClient: GraphClient): void {
-  for (const tool of api.endpoints) {
-    // Create a zod schema for the parameters
-    const paramSchema: Record<string, any> = {};
-    if (tool.parameters && tool.parameters.length > 0) {
-      for (const param of tool.parameters) {
-        // Use z.any() as a fallback schema if the parameter schema is not specified
-        paramSchema[param.name] = param.schema || z.any();
-      }
-    }
-
-    server.tool(
-      tool.alias,
-      tool.description ?? '',
-      paramSchema,
-      {
-        title: tool.alias,
-        readOnlyHint: tool.method.toUpperCase() === 'GET',
-      },
-      async (params, extra) => {
-        logger.info(`Tool ${tool.alias} called with params: ${JSON.stringify(params)}`);
-        try {
-          logger.info(`params: ${JSON.stringify(params)}`);
-
-          const parameterDefinitions = tool.parameters || [];
-
-          let path = tool.path;
-          const queryParams: Record<string, string> = {};
-          const headers: Record<string, string> = {};
-          let body: any = null;
-          for (let [paramName, paramValue] of Object.entries(params)) {
-            const fixedParamName = paramName.replace(/__/g, '$');
-            const paramDef = parameterDefinitions.find((p) => p.name === paramName);
-
-            if (paramDef) {
-              switch (paramDef.type) {
-                case 'Path':
-                  path = path
-                    .replace(`{${paramName}}`, encodeURIComponent(paramValue as string))
-                    .replace(`:${paramName}`, encodeURIComponent(paramValue as string));
-                  break;
-
-                case 'Query':
-                  queryParams[fixedParamName] = `${paramValue}`;
-                  break;
-
-                case 'Body':
-                  body = paramValue;
-                  break;
-
-                case 'Header':
-                  headers[fixedParamName] = `${paramValue}`;
-                  break;
-              }
-            } else if (paramName === 'body') {
-              body = paramValue;
-              logger.info(`Set legacy body param: ${JSON.stringify(body)}`);
-            }
-          }
-
-          if (Object.keys(queryParams).length > 0) {
-            const queryString = Object.entries(queryParams)
-              .map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(value)}`)
-              .join('&');
-            path = `${path}${path.includes('?') ? '&' : '?'}${queryString}`;
-          }
-
-          const options: any = {
-            method: tool.method.toUpperCase(),
-            headers,
-          };
-
-          if (options.method !== 'GET' && body) {
-            options.body = JSON.stringify(body);
-          }
-
-          logger.info(`Making graph request to ${path} with options: ${JSON.stringify(options)}`);
-          const response = await graphClient.graphRequest(path, options);
-
-          // Convert McpResponse to CallToolResult with the correct structure
-          const content: ContentItem[] = response.content.map((item) => {
-            // GraphClient only returns text content items, so create proper TextContent items
-            const textContent: TextContent = {
-              type: 'text',
-              text: item.text,
-            };
-            return textContent;
-          });
-
-          const result: CallToolResult = {
-            content,
-            _meta: response._meta,
-            isError: response.isError,
-          };
-
-          return result;
-        } catch (error) {
-          logger.error(`Error in tool ${tool.alias}: ${(error as Error).message}`);
-          const errorContent: TextContent = {
-            type: 'text',
-            text: JSON.stringify({
-              error: `Error in tool ${tool.alias}: ${(error as Error).message}`,
-            }),
-          };
-
-          return {
-            content: [errorContent],
-            isError: true,
-          };
-        }
-      }
-    );
-  }
-}

package/src/index.ts

@@ -1,46 +0,0 @@
-#!/usr/bin/env node
-
-import { parseArgs } from './cli.js';
-import logger from './logger.js';
-import AuthManager from './auth.js';
-import MicrosoftGraphServer from './server.js';
-import { version } from './version.js';
-
-async function main(): Promise<void> {
-  try {
-    const args = parseArgs();
-
-    const authManager = new AuthManager();
-    await authManager.loadTokenCache();
-
-    if (args.login) {
-      await authManager.acquireTokenByDeviceCode();
-      logger.info('Login completed, testing connection with Graph API...');
-      const result = await authManager.testLogin();
-      console.log(JSON.stringify(result));
-      process.exit(0);
-    }
-
-    if (args.verifyLogin) {
-      logger.info('Verifying login...');
-      const result = await authManager.testLogin();
-      console.log(JSON.stringify(result));
-      process.exit(0);
-    }
-
-    if (args.logout) {
-      await authManager.logout();
-      console.log(JSON.stringify({ message: 'Logged out successfully' }));
-      process.exit(0);
-    }
-
-    const server = new MicrosoftGraphServer(authManager, args);
-    await server.initialize(version);
-    await server.start();
-  } catch (error) {
-    logger.error(`Startup error: ${error}`);
-    process.exit(1);
-  }
-}
-
-main();

package/src/logger.ts

@@ -1,43 +0,0 @@
-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');
-
-if (!fs.existsSync(logsDir)) {
-  fs.mkdirSync(logsDir);
-}
-
-const logger = winston.createLogger({
-  level: process.env.LOG_LEVEL || 'info',
-  format: winston.format.combine(
-    winston.format.timestamp({
-      format: 'YYYY-MM-DD HH:mm:ss',
-    }),
-    winston.format.printf(({ level, message, timestamp }) => {
-      return `${timestamp} ${level.toUpperCase()}: ${message}`;
-    })
-  ),
-  transports: [
-    new winston.transports.File({
-      filename: path.join(logsDir, 'error.log'),
-      level: 'error',
-    }),
-    new winston.transports.File({
-      filename: path.join(logsDir, 'mcp-server.log'),
-    }),
-  ],
-});
-
-export const enableConsoleLogging = (): void => {
-  logger.add(
-    new winston.transports.Console({
-      format: winston.format.combine(winston.format.colorize(), winston.format.simple()),
-      silent: process.env.SILENT === 'true',
-    })
-  );
-};
-
-export default logger;

package/src/server.ts

@@ -1,46 +0,0 @@
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import logger, { enableConsoleLogging } from './logger.js';
-import { registerAuthTools } from './auth-tools.js';
-import { registerGraphTools } from './graph-tools.js';
-import GraphClient from './graph-client.js';
-import AuthManager from './auth.js';
-import type { CommandOptions } from './cli.ts';
-
-class MicrosoftGraphServer {
-  private authManager: AuthManager;
-  private options: CommandOptions;
-  private graphClient: GraphClient;
-  private server: McpServer | null;
-
-  constructor(authManager: AuthManager, options: CommandOptions = {}) {
-    this.authManager = authManager;
-    this.options = options;
-    this.graphClient = new GraphClient(authManager);
-    this.server = null;
-  }
-
-  async initialize(version: string): Promise<void> {
-    this.server = new McpServer({
-      name: 'Microsoft365MCP',
-      version,
-    });
-
-    registerAuthTools(this.server, this.authManager);
-    registerGraphTools(this.server, this.graphClient);
-  }
-
-  async start(): Promise<void> {
-    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.ts

@@ -1,9 +0,0 @@
-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: string = packageJson.version;