@softeria/ms-365-mcp-server 0.3.5 → 0.4.0

package/src/generated/endpoint-types.ts

@@ -0,0 +1,27 @@
+import { z } from 'zod';
+
+export type HttpMethod = 'get' | 'post' | 'put' | 'delete' | 'patch';
+
+export type Parameter = {
+  name: string;
+  type: 'Query' | 'Path' | 'Body' | 'Header';
+  schema: z.ZodType<any>;
+  description?: string;
+};
+
+export type Endpoint = {
+  method: HttpMethod;
+  path: string;
+  alias: string;
+  description?: string;
+  requestFormat: 'json';
+  parameters?: Parameter[];
+  response: z.ZodType<any>;
+  errors?: Array<{
+    status: number;
+    description?: string;
+    schema?: z.ZodType<any>;
+  }>;
+};
+
+export type Endpoints = Endpoint[];

package/src/generated/hack.ts

@@ -0,0 +1,50 @@
+import { Endpoint, Parameter } from './endpoint-types.js';
+import { z } from 'zod';
+
+export function makeApi(endpoints: Endpoint[]) {
+  return endpoints;
+}
+
+export class Zodios {
+  endpoints: Endpoint[];
+
+  constructor(baseUrlOrEndpoints: Endpoint[] | string, endpoints?: any, options?: any) {
+    if (typeof baseUrlOrEndpoints === 'string') {
+      throw new Error('No such hack');
+    }
+    this.endpoints = baseUrlOrEndpoints.map((endpoint) => {
+      endpoint.parameters = endpoint.parameters || [];
+      for (const parameter of endpoint.parameters) {
+        // We need a hack since MCP won't support $ in parameter names
+        parameter.name = parameter.name.replace(/\$/g, '__');
+      }
+
+      const pathParamRegex = /:([a-zA-Z0-9]+)/g;
+      const pathParams = [];
+      let match;
+      while ((match = pathParamRegex.exec(endpoint.path)) !== null) {
+        pathParams.push(match[1]);
+      }
+
+      for (const pathParam of pathParams) {
+        const paramExists = endpoint.parameters.some(
+          (param) => param.name === pathParam || param.name === pathParam.replace(/\$/g, '__')
+        );
+
+        if (!paramExists) {
+          const newParam: Parameter = {
+            name: pathParam,
+            type: 'Path',
+            schema: z.string().describe(`Path parameter: ${pathParam}`),
+            description: `Path parameter: ${pathParam}`,
+          };
+          endpoint.parameters.push(newParam);
+        }
+      }
+
+      return endpoint;
+    });
+  }
+}
+
+export type ZodiosOptions = {};

package/src/{graph-client.mjs → graph-client.ts}

@@ -1,12 +1,41 @@
-import logger from './logger.mjs';
+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 {
-  constructor(authManager) {
+  private authManager: AuthManager;
+  private sessions: Map<string, string>;
+
+  constructor(authManager: AuthManager) {
     this.authManager = authManager;
     this.sessions = new Map();
   }
 
-  async createSession(filePath) {
+  async createSession(filePath: string): Promise<string | null> {
     try {
       if (!filePath) {
         logger.error('No file path provided for Excel session');
@@ -14,7 +43,7 @@ class GraphClient {
       }
 
       if (this.sessions.has(filePath)) {
-        return this.sessions.get(filePath);
+        return this.sessions.get(filePath) || null;
       }
 
       logger.info(`Creating new Excel session for file: ${filePath}`);
@@ -49,12 +78,13 @@ class GraphClient {
     }
   }
 
-  async graphRequest(endpoint, options = {}) {
+  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;
-      let sessionId = null;
+      let url: string;
+      let sessionId: string | null = null;
 
       if (
         options.excelFile &&
@@ -62,7 +92,7 @@ class GraphClient {
         !endpoint.startsWith('/users') &&
         !endpoint.startsWith('/me')
       ) {
-        sessionId = this.sessions.get(options.excelFile);
+        sessionId = this.sessions.get(options.excelFile) || null;
 
         if (!sessionId) {
           sessionId = await this.createSession(options.excelFile);
@@ -87,12 +117,15 @@ class GraphClient {
         };
       }
 
-      const headers = {
+      const headers: Record<string, string> = {
+        ...options.headers,
         Authorization: `Bearer ${accessToken}`,
         'Content-Type': 'application/json',
         ...(sessionId && { 'workbook-session-id': sessionId }),
-        ...options.headers,
       };
+      delete options.headers;
+
+      logger.info(` ** Making request to ${url} with options: ${JSON.stringify(options)}`);
 
       const response = await fetch(url, {
         headers,
@@ -142,12 +175,13 @@ class GraphClient {
     } catch (error) {
       logger.error(`Error in Graph API request: ${error}`);
       return {
-        content: [{ type: 'text', text: JSON.stringify({ error: error.message }) }],
+        content: [{ type: 'text', text: JSON.stringify({ error: (error as Error).message }) }],
+        isError: true,
       };
     }
   }
 
-  async formatResponse(response, rawResponse = false) {
+  async formatResponse(response: Response, rawResponse = false): Promise<McpResponse> {
     try {
       if (response.status === 204) {
         return {
@@ -188,7 +222,7 @@ class GraphClient {
 
       const result = await response.json();
 
-      const removeODataProps = (obj) => {
+      const removeODataProps = (obj: any): void => {
         if (!obj || typeof obj !== 'object') return;
 
         if (Array.isArray(obj)) {
@@ -217,7 +251,7 @@ class GraphClient {
     }
   }
 
-  async closeSession(filePath) {
+  async closeSession(filePath: string): Promise<McpResponse> {
     if (!filePath || !this.sessions.has(filePath)) {
       return {
         content: [
@@ -240,7 +274,7 @@ class GraphClient {
           headers: {
             Authorization: `Bearer ${accessToken}`,
             'Content-Type': 'application/json',
-            'workbook-session-id': sessionId,
+            'workbook-session-id': sessionId!,
           },
         }
       );
@@ -267,14 +301,15 @@ class GraphClient {
             text: JSON.stringify({ error: `Failed to close session for ${filePath}` }),
           },
         ],
+        isError: true,
       };
     }
   }
 
-  async closeAllSessions() {
-    const results = [];
+  async closeAllSessions(): Promise<McpResponse> {
+    const results: McpResponse[] = [];
 
-    for (const [filePath, _] of this.sessions) {
+    for (const [filePath] of this.sessions) {
       const result = await this.closeSession(filePath);
       results.push(result);
     }

package/src/graph-tools.ts

@@ -0,0 +1,174 @@
+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/{index.mjs → src/index.ts}

@@ -1,12 +1,12 @@
 #!/usr/bin/env node
 
-import { parseArgs } from './src/cli.mjs';
-import logger from './src/logger.mjs';
-import AuthManager from './src/auth.mjs';
-import MicrosoftGraphServer from './src/server.mjs';
-import { version } from './src/version.mjs';
+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() {
+async function main(): Promise<void> {
   try {
     const args = parseArgs();
 

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

@@ -31,7 +31,7 @@ const logger = winston.createLogger({
   ],
 });
 
-export const enableConsoleLogging = () => {
+export const enableConsoleLogging = (): void => {
   logger.add(
     new winston.transports.Console({
       format: winston.format.combine(winston.format.colorize(), winston.format.simple()),

package/src/{server.mjs → server.ts}

@@ -1,29 +1,36 @@
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import logger, { enableConsoleLogging } from './logger.mjs';
-import { registerAuthTools } from './auth-tools.mjs';
-import { registerDynamicTools } from './dynamic-tools.mjs';
-import GraphClient from './graph-client.mjs';
+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 {
-  constructor(authManager, options = {}) {
+  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) {
+  async initialize(version: string): Promise<void> {
     this.server = new McpServer({
       name: 'Microsoft365MCP',
       version,
     });
 
     registerAuthTools(this.server, this.authManager);
-    await registerDynamicTools(this.server, this.graphClient);
+    registerGraphTools(this.server, this.graphClient);
   }
 
-  async start() {
+  async start(): Promise<void> {
     if (this.options.v) {
       enableConsoleLogging();
     }
@@ -31,7 +38,7 @@ class MicrosoftGraphServer {
     logger.info('Microsoft 365 MCP Server starting...');
 
     const transport = new StdioServerTransport();
-    await this.server.connect(transport);
+    await this.server!.connect(transport);
     logger.info('Server connected to transport');
   }
 }

package/src/version.ts

@@ -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: string = packageJson.version;

package/test/{auth-tools.test.js → auth-tools.test.ts}

@@ -1,94 +1,97 @@
 import { describe, expect, it, vi, beforeEach } from 'vitest';
 
-// Mock Zod
 vi.mock('zod', () => {
   const mockZod = {
     boolean: () => ({
       default: () => ({
-        describe: () => 'mocked-zod-boolean'
-      })
+        describe: () => 'mocked-zod-boolean',
+      }),
     }),
     object: () => ({
-      strict: () => 'mocked-zod-object'
-    })
+      strict: () => 'mocked-zod-object',
+    }),
   };
   return { z: mockZod };
 });
 
-import { registerAuthTools } from '../src/auth-tools.mjs';
+import { registerAuthTools } from '../src/auth-tools.js';
 
 describe('Auth Tools', () => {
-  let server;
-  let authManager;
-  let loginTool;
-  
+  let server: any;
+  let authManager: any;
+  let loginTool: any;
+
   beforeEach(() => {
     loginTool = vi.fn();
-    
+
     server = {
       tool: vi.fn((name, schema, handler) => {
         if (name === 'login') {
           loginTool = handler;
         }
-      })
+      }),
     };
-    
+
     authManager = {
       testLogin: vi.fn(),
-      acquireTokenByDeviceCode: 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' }
+        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' }
+        userData: { displayName: 'Test User' },
       });
-      
-      authManager.acquireTokenByDeviceCode.mockImplementation(callback => {
-        callback('Login instructions');
-        return Promise.resolve();
-      });
-      
+
+      authManager.acquireTokenByDeviceCode.mockImplementation(
+        (callback: (text: string) => void) => {
+          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();
+        message: 'Not logged in',
       });
-      
+
+      authManager.acquireTokenByDeviceCode.mockImplementation(
+        (callback: (text: string) => void) => {
+          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');
     });
   });
-});
+});

package/test/{cli.test.js → cli.test.ts}

@@ -1,5 +1,5 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import { parseArgs } from '../src/cli.mjs';
+import { parseArgs } from '../src/cli.js';
 
 vi.mock('commander', () => {
   const mockCommand = {
@@ -16,7 +16,7 @@ vi.mock('commander', () => {
   };
 });
 
-vi.mock('../auth.mjs', () => {
+vi.mock('../src/auth.js', () => {
   return {
     default: vi.fn().mockImplementation(() => ({
       getToken: vi.fn().mockResolvedValue('mock-token'),
@@ -42,4 +42,4 @@ describe('CLI Module', () => {
       expect(result).toEqual({ file: 'test.xlsx' });
     });
   });
-});
+});