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

package/dist/generated/endpoint-types.js

@@ -0,0 +1 @@
+export {};

package/dist/generated/hack.js

@@ -0,0 +1,37 @@
+import { z } from 'zod';
+export function makeApi(endpoints) {
+    return endpoints;
+}
+export class Zodios {
+    constructor(baseUrlOrEndpoints, endpoints, options) {
+        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 = {
+                        name: pathParam,
+                        type: 'Path',
+                        schema: z.string().describe(`Path parameter: ${pathParam}`),
+                        description: `Path parameter: ${pathParam}`,
+                    };
+                    endpoint.parameters.push(newParam);
+                }
+            }
+            return endpoint;
+        });
+    }
+}

package/dist/graph-client.js

@@ -0,0 +1,254 @@
+import logger from './logger.js';
+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) || 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, options = {}) {
+        try {
+            logger.info(`Calling ${endpoint} with options: ${JSON.stringify(options)}`);
+            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) || 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 = {
+                ...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.message }) }],
+                isError: true,
+            };
+        }
+    }
+    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}` }),
+                    },
+                ],
+                isError: true,
+            };
+        }
+    }
+    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/dist/graph-tools.js

@@ -0,0 +1,98 @@
+import logger from './logger.js';
+import { api } from './generated/client.js';
+import { z } from 'zod';
+export function registerGraphTools(server, graphClient) {
+    for (const tool of api.endpoints) {
+        // Create a zod schema for the parameters
+        const paramSchema = {};
+        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 = {};
+                const headers = {};
+                let body = 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))
+                                    .replace(`:${paramName}`, encodeURIComponent(paramValue));
+                                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 = {
+                    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 = response.content.map((item) => {
+                    // GraphClient only returns text content items, so create proper TextContent items
+                    const textContent = {
+                        type: 'text',
+                        text: item.text,
+                    };
+                    return textContent;
+                });
+                const result = {
+                    content,
+                    _meta: response._meta,
+                    isError: response.isError,
+                };
+                return result;
+            }
+            catch (error) {
+                logger.error(`Error in tool ${tool.alias}: ${error.message}`);
+                const errorContent = {
+                    type: 'text',
+                    text: JSON.stringify({
+                        error: `Error in tool ${tool.alias}: ${error.message}`,
+                    }),
+                };
+                return {
+                    content: [errorContent],
+                    isError: true,
+                };
+            }
+        });
+    }
+}

package/dist/index.js

@@ -0,0 +1,39 @@
+#!/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() {
+    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/dist/logger.js

@@ -0,0 +1,33 @@
+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 = () => {
+    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/dist/server.js

@@ -0,0 +1,32 @@
+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';
+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);
+        registerGraphTools(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 → dist/version.js}

@@ -1,9 +1,7 @@
 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/package.json

@@ -1,21 +1,20 @@
 {
   "name": "@softeria/ms-365-mcp-server",
-  "version": "0.3.5",
+  "version": "0.4.1",
   "description": "Microsoft 365 MCP Server",
   "type": "module",
-  "main": "index.mjs",
+  "main": "dist/index.js",
   "bin": {
-    "ms-365-mcp-server": "index.mjs"
+    "ms-365-mcp-server": "dist/index.js"
   },
   "scripts": {
+    "build": "tsc",
     "test": "vitest run",
     "test:watch": "vitest",
-    "start": "node index.mjs",
-    "format": "prettier --write \"**/*.{js,mjs,json,md}\"",
-    "release": "node bin/release.mjs",
-    "download-openapi": "node bin/download-openapi.mjs",
-    "inspect": "npx @modelcontextprotocol/inspector node index.mjs",
-    "postinstall": "npm run download-openapi"
+    "dev": "tsx src/index.ts",
+    "format": "prettier --write \"**/*.{ts,mts,js,mjs,json,md}\"",
+    "release": "ts-node --esm bin/release.mts",
+    "inspect": "npx @modelcontextprotocol/inspector tsx src/index.ts"
   },
   "keywords": [
     "microsoft",
@@ -38,7 +37,11 @@
     "zod": "^3.24.2"
   },
   "devDependencies": {
+    "@redocly/cli": "^1.34.3",
+    "@types/node": "^22.15.15",
     "prettier": "^3.5.3",
+    "tsx": "^4.19.4",
+    "typescript": "^5.8.3",
     "vitest": "^3.1.1"
   },
   "repository": {

package/src/{auth-tools.mjs → auth-tools.ts}

@@ -1,6 +1,8 @@
 import { z } from 'zod';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import AuthManager from './auth.js';
 
-export function registerAuthTools(server, authManager) {
+export function registerAuthTools(server: McpServer, authManager: AuthManager): void {
   server.tool(
     'login',
     {
@@ -16,7 +18,7 @@ export function registerAuthTools(server, authManager) {
                 {
                   type: 'text',
                   text: JSON.stringify({
-                    message: 'Already logged in',
+                    status: 'Already logged in',
                     ...loginStatus,
                   }),
                 },
@@ -25,7 +27,7 @@ export function registerAuthTools(server, authManager) {
           }
         }
 
-        const text = await new Promise((r) => {
+        const text = await new Promise<string>((r) => {
           authManager.acquireTokenByDeviceCode(r);
         });
         return {
@@ -41,7 +43,7 @@ export function registerAuthTools(server, authManager) {
           content: [
             {
               type: 'text',
-              text: JSON.stringify({ error: `Authentication failed: ${error.message}` }),
+              text: JSON.stringify({ error: `Authentication failed: ${(error as Error).message}` }),
             },
           ],
         };
@@ -72,7 +74,7 @@ export function registerAuthTools(server, authManager) {
     }
   });
 
-  server.tool('verify-login', {}, async () => {
+  server.tool('verify-login', async () => {
     const testResult = await authManager.testLogin();
 
     return {