@softeria/ms-365-mcp-server 0.1.9

package/.github/workflows/npm-publish.yml

@@ -0,0 +1,33 @@
+# This workflow will run tests using node and then publish a package to GitHub Packages when a release is created
+# For more information see: https://docs.github.com/en/actions/publishing-packages/publishing-nodejs-packages
+
+name: Node.js Package
+
+on:
+  release:
+    types: [ created ]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 20
+      - run: npm ci
+      - run: npm test
+
+  publish-npm:
+    needs: build
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 20
+          registry-url: https://registry.npmjs.org/
+      - run: npm ci
+      - run: npm publish
+        env:
+          NODE_AUTH_TOKEN: ${{secrets.npm_token}}

package/.prettierrc

@@ -0,0 +1,7 @@
+{
+  "semi": true,
+  "singleQuote": true,
+  "trailingComma": "es5",
+  "printWidth": 100,
+  "tabWidth": 2
+}

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Softeria
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,70 @@
+# ms-365-mcp-server
+
+Microsoft 365 MCP Server
+
+A Model Context Protocol (MCP) server for interacting with Microsoft 365 services through the Graph API.
+
+[![Test Status](https://img.shields.io/badge/tests-passing-brightgreen)]()
+
+## Features
+
+- Authentication using Microsoft Authentication Library (MSAL)
+- Excel file operations:
+  - Update cell values
+  - Create and manage charts
+  - Format cells
+  - Sort data
+  - Create tables
+  - Read cell values
+  - List worksheets
+- Built on the Model Context Protocol
+
+## Installation
+
+```bash
+npm install -g ms-365-mcp-server
+```
+
+Or use directly with npx:
+
+```bash
+npx ms-365-mcp-server
+```
+
+## Usage
+
+### Command Line Options
+
+```bash
+npx ms-365-mcp-server [options]
+```
+
+Options:
+
+- `--login`: Force login using device code flow
+- `--logout`: Log out and clear saved credentials
+- `--file <path>`: Excel file path to use (default: "/Livet.xlsx")
+- `--silent`: Run without informational messages to stderr
+
+### Authentication
+
+The first time you run the server, it will automatically initiate the device code flow authentication. You'll see instructions in the terminal about how to complete the authentication in your browser.
+
+Authentication tokens are cached securely in your system's credential store with fallback to file storage if needed.
+
+### MCP Tools
+
+This server provides several MCP tools for interacting with Excel files:
+
+- `login`: Force a new login with Microsoft
+- `logout`: Log out of Microsoft and clear credentials
+- `update-excel`: Update cell values in an Excel worksheet
+- `create-chart`: Create a chart in an Excel worksheet
+- `format-range`: Apply formatting to a range of cells
+- `sort-range`: Sort a range of cells
+- `create-table`: Create a table from a range of cells
+- `get-range`: Get values from a range of cells
+- `list-worksheets`: List all worksheets in the workbook
+- `close-session`: Close the current Excel session
+- `delete-chart`: Delete a chart from a worksheet
+- `get-charts`: Get all charts in a worksheet

package/auth.mjs

@@ -0,0 +1,153 @@
+import { PublicClientApplication } from '@azure/msal-node';
+import keytar from 'keytar';
+import { fileURLToPath } from 'url';
+import path from 'path';
+import fs from 'fs';
+import logger from './logger.mjs';
+
+const SERVICE_NAME = 'ms-365-mcp-server';
+const TOKEN_CACHE_ACCOUNT = 'msal-token-cache';
+const FALLBACK_DIR = path.dirname(fileURLToPath(import.meta.url));
+const FALLBACK_PATH = path.join(FALLBACK_DIR, '.token-cache.json');
+
+const DEFAULT_CONFIG = {
+  auth: {
+    clientId: '084a3e9f-a9f4-43f7-89f9-d229cf97853e',
+    authority: 'https://login.microsoftonline.com/common',
+  },
+};
+
+const DEFAULT_SCOPES = [
+  'Files.ReadWrite',
+  'Files.ReadWrite.All',
+  'Sites.ReadWrite.All',
+  'User.Read',
+  'User.ReadBasic.All',
+];
+
+class AuthManager {
+  constructor(config = DEFAULT_CONFIG, scopes = DEFAULT_SCOPES) {
+    this.config = config;
+    this.scopes = scopes;
+    this.msalApp = new PublicClientApplication(this.config);
+    this.accessToken = null;
+    this.tokenExpiry = null;
+  }
+
+  async loadTokenCache() {
+    try {
+      let cacheData;
+
+      try {
+        const cachedData = await keytar.getPassword(SERVICE_NAME, TOKEN_CACHE_ACCOUNT);
+        if (cachedData) {
+          cacheData = cachedData;
+        }
+      } catch (keytarError) {
+        logger.warn(`Keychain access failed, falling back to file storage: ${keytarError.message}`);
+      }
+
+      if (!cacheData && fs.existsSync(FALLBACK_PATH)) {
+        cacheData = fs.readFileSync(FALLBACK_PATH, 'utf8');
+      }
+
+      if (cacheData) {
+        this.msalApp.getTokenCache().deserialize(cacheData);
+      }
+    } catch (error) {
+      logger.error(`Error loading token cache: ${error.message}`);
+    }
+  }
+
+  async saveTokenCache() {
+    try {
+      const cacheData = this.msalApp.getTokenCache().serialize();
+
+      try {
+        await keytar.setPassword(SERVICE_NAME, TOKEN_CACHE_ACCOUNT, cacheData);
+      } catch (keytarError) {
+        logger.warn(`Keychain save failed, falling back to file storage: ${keytarError.message}`);
+
+        fs.writeFileSync(FALLBACK_PATH, cacheData);
+      }
+    } catch (error) {
+      logger.error(`Error saving token cache: ${error.message}`);
+    }
+  }
+
+  async getToken(forceRefresh = false) {
+    if (this.accessToken && this.tokenExpiry && this.tokenExpiry > Date.now() && !forceRefresh) {
+      return this.accessToken;
+    }
+
+    const accounts = await this.msalApp.getTokenCache().getAllAccounts();
+
+    if (accounts.length > 0) {
+      const silentRequest = {
+        account: accounts[0],
+        scopes: this.scopes,
+      };
+
+      try {
+        const response = await this.msalApp.acquireTokenSilent(silentRequest);
+        this.accessToken = response.accessToken;
+        this.tokenExpiry = new Date(response.expiresOn).getTime();
+        return this.accessToken;
+      } catch (error) {
+        logger.info('Silent token acquisition failed, using device code flow');
+      }
+    }
+
+    throw new Error('No valid token found');
+  }
+
+  async acquireTokenByDeviceCode() {
+    const deviceCodeRequest = {
+      scopes: this.scopes,
+      deviceCodeCallback: (response) => {
+        // We need to show this message to the user in console
+        console.log('\n' + response.message + '\n');
+        logger.info('Device code login initiated');
+      },
+    };
+
+    try {
+      const response = await this.msalApp.acquireTokenByDeviceCode(deviceCodeRequest);
+      this.accessToken = response.accessToken;
+      this.tokenExpiry = new Date(response.expiresOn).getTime();
+      await this.saveTokenCache();
+      return this.accessToken;
+    } catch (error) {
+      logger.error(`Error in device code flow: ${error.message}`);
+      throw error;
+    }
+  }
+
+  async logout() {
+    try {
+      const accounts = await this.msalApp.getTokenCache().getAllAccounts();
+      for (const account of accounts) {
+        await this.msalApp.getTokenCache().removeAccount(account);
+      }
+      this.accessToken = null;
+      this.tokenExpiry = null;
+
+      try {
+        await keytar.deletePassword(SERVICE_NAME, TOKEN_CACHE_ACCOUNT);
+      } catch (keytarError) {
+        logger.warn(`Keychain deletion failed: ${keytarError.message}`);
+      }
+
+      if (fs.existsSync(FALLBACK_PATH)) {
+        fs.unlinkSync(FALLBACK_PATH);
+      }
+
+      return true;
+    } catch (error) {
+      logger.error(`Error during logout: ${error.message}`);
+      throw error;
+    }
+  }
+}
+
+export default AuthManager;

package/cli.mjs

@@ -0,0 +1,21 @@
+import { Command } from 'commander';
+import { readFileSync } from 'fs';
+
+const packageJson = JSON.parse(readFileSync(new URL('./package.json', import.meta.url)));
+const version = packageJson.version;
+
+const program = new Command();
+
+program
+  .name('ms-365-mcp-server')
+  .description('Microsoft 365 MCP Server')
+  .version(version)
+  .option('-v', 'Enable verbose logging')
+  .option('--login', 'Login using device code flow')
+  .option('--logout', 'Log out and clear saved credentials')
+  .option('--test-login', 'Test login without starting the server');
+
+export function parseArgs() {
+  program.parse();
+  return program.opts();
+}

package/index.mjs

@@ -0,0 +1,518 @@
+#!/usr/bin/env node
+
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { z } from 'zod';
+import { parseArgs } from './cli.mjs';
+import { readFileSync } from 'fs';
+import logger, { enableConsoleLogging } from './logger.mjs';
+import AuthManager from './auth.mjs';
+
+const packageJson = JSON.parse(readFileSync(new URL('./package.json', import.meta.url)));
+export const version = packageJson.version;
+
+const args = parseArgs();
+const filePath = args.file || '/Livet.xlsx';
+
+const authManager = new AuthManager();
+await authManager.loadTokenCache();
+
+let sessionId = null;
+
+async function createSession() {
+  try {
+    logger.info('Creating new Excel session...');
+    const accessToken = await 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');
+    sessionId = result.id;
+    return sessionId;
+  } catch (error) {
+    logger.error(`Error creating Excel session: ${error}`);
+    return null;
+  }
+}
+
+async function graphRequest(endpoint, options = {}) {
+  try {
+    let accessToken = await authManager.getToken();
+
+    const headers = {
+      Authorization: `Bearer ${accessToken}`,
+      'Content-Type': 'application/json',
+      ...(sessionId && { 'workbook-session-id': sessionId }),
+      ...options.headers,
+    };
+
+    const response = await fetch(
+      `https://graph.microsoft.com/v1.0/me/drive/root:${filePath}:${endpoint}`,
+      {
+        headers,
+        ...options,
+      }
+    );
+
+    if (response.status === 401) {
+      logger.info('Access token expired, refreshing...');
+      const newToken = await authManager.getToken(true);
+      await createSession();
+
+      headers.Authorization = `Bearer ${newToken}`;
+      if (sessionId) {
+        headers['workbook-session-id'] = sessionId;
+      }
+
+      const retryResponse = await fetch(
+        `https://graph.microsoft.com/v1.0/me/drive/root:${filePath}:${endpoint}`,
+        {
+          headers,
+          ...options,
+        }
+      );
+
+      if (!retryResponse.ok) {
+        throw new Error(`Graph API error: ${retryResponse.status} ${await retryResponse.text()}`);
+      }
+
+      return formatResponse(retryResponse);
+    }
+
+    if (!response.ok) {
+      throw new Error(`Graph API error: ${response.status} ${await response.text()}`);
+    }
+
+    return formatResponse(response);
+  } catch (error) {
+    logger.error(`Error in Graph API request: ${error}`);
+    return {
+      content: [{ type: 'text', text: JSON.stringify({ error: error.message }) }],
+    };
+  }
+}
+
+async function formatResponse(response) {
+  try {
+    if (response.status === 204) {
+      return {
+        content: [
+          {
+            type: 'text',
+            text: JSON.stringify({
+              message: 'Operation completed successfully',
+            }),
+          },
+        ],
+      };
+    }
+
+    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) {
+    return {
+      content: [{ type: 'text', text: JSON.stringify({ message: 'Success' }) }],
+    };
+  }
+}
+
+const server = new McpServer({
+  name: 'ExcelUpdater',
+  version,
+});
+
+server.tool('login', {}, async () => {
+  try {
+    await authManager.getToken(true);
+    return {
+      content: [
+        {
+          type: 'text',
+          text: JSON.stringify({ message: 'Authentication successful' }),
+        },
+      ],
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: 'text',
+          text: JSON.stringify({ error: 'Authentication failed' }),
+        },
+      ],
+    };
+  }
+});
+
+server.tool('logout', {}, async () => {
+  try {
+    await authManager.logout();
+    return {
+      content: [
+        {
+          type: 'text',
+          text: JSON.stringify({ message: 'Logged out successfully' }),
+        },
+      ],
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: 'text',
+          text: JSON.stringify({ error: 'Logout failed' }),
+        },
+      ],
+    };
+  }
+});
+
+server.tool(
+  'update-excel',
+  {
+    worksheet: z.string().default('Sheet1').describe('Worksheet name'),
+    address: z.string().describe("Range address (e.g., 'A1:B5')"),
+    values: z.array(z.array(z.any())).describe('Values to update'),
+  },
+  async ({ worksheet, address, values }) => {
+    return graphRequest(`/workbook/worksheets('${worksheet}')/range(address='${address}')`, {
+      method: 'PATCH',
+      body: JSON.stringify({ values }),
+    });
+  }
+);
+
+server.tool(
+  'create-chart',
+  {
+    worksheet: z.string().default('Sheet1').describe('Worksheet name'),
+    type: z.string().describe("Chart type (e.g., 'ColumnClustered', 'Line', 'Pie')"),
+    dataRange: z.string().describe("Data range for the chart (e.g., 'A1:B10')"),
+    title: z.string().optional().describe('Title for the chart'),
+    position: z
+      .object({
+        x: z.number().describe('X position'),
+        y: z.number().describe('Y position'),
+        width: z.number().describe('Width'),
+        height: z.number().describe('Height'),
+      })
+      .describe('Chart position and dimensions'),
+  },
+  async ({ worksheet, type, dataRange, title, position }) => {
+    const body = {
+      type,
+      sourceData: dataRange,
+      position,
+    };
+
+    if (title) {
+      body.title = { text: title };
+    }
+
+    return graphRequest(`/workbook/worksheets('${worksheet}')/charts/add`, {
+      method: 'POST',
+      body: JSON.stringify(body),
+    });
+  }
+);
+
+server.tool(
+  'format-range',
+  {
+    worksheet: z.string().default('Sheet1').describe('Worksheet name'),
+    range: z.string().describe("Range address (e.g., 'A1:B5')"),
+    format: z
+      .object({
+        fill: z
+          .object({
+            color: z.string().optional().describe("Background color (e.g., '#FFFF00')"),
+          })
+          .optional(),
+        font: z
+          .object({
+            bold: z.boolean().optional().describe('Bold text'),
+            italic: z.boolean().optional().describe('Italic text'),
+            color: z.string().optional().describe("Font color (e.g., '#FF0000')"),
+            size: z.number().optional().describe('Font size'),
+          })
+          .optional(),
+        numberFormat: z.string().optional().describe("Number format (e.g., '0.00%', 'mm/dd/yyyy')"),
+      })
+      .describe('Formatting to apply'),
+  },
+  async ({ worksheet, range, format }) => {
+    return graphRequest(`/workbook/worksheets('${worksheet}')/range(address='${range}')/format`, {
+      method: 'PATCH',
+      body: JSON.stringify(format),
+    });
+  }
+);
+
+server.tool(
+  'sort-range',
+  {
+    worksheet: z.string().default('Sheet1').describe('Worksheet name'),
+    range: z.string().describe("Range address (e.g., 'A1:B5')"),
+    sortFields: z
+      .array(
+        z.object({
+          key: z.number().describe('Column index to sort by (zero-based)'),
+          sortOn: z
+            .string()
+            .optional()
+            .describe("Sorting criteria (e.g., 'Value', 'CellColor', 'FontColor', 'Icon')"),
+          ascending: z.boolean().optional().describe('Sort in ascending order (default: true)'),
+          color: z
+            .object({
+              color: z.string().describe('HTML color code'),
+              type: z.string().describe("Color type (e.g., 'Background', 'Font')"),
+            })
+            .optional()
+            .describe('Color information for sorting by color'),
+          dataOption: z
+            .string()
+            .optional()
+            .describe("Data option for sorting (e.g., 'Normal', 'TextAsNumber')"),
+          icon: z
+            .object({
+              set: z.string().describe('Icon set name'),
+              index: z.number().describe('Icon index'),
+            })
+            .optional()
+            .describe('Icon information for sorting by icon'),
+        })
+      )
+      .describe('Fields to sort by'),
+    matchCase: z.boolean().optional().describe('Whether the sort is case-sensitive'),
+    hasHeaders: z.boolean().optional().describe('Whether the range has headers (default: false)'),
+    orientation: z.string().optional().describe("Sort orientation ('Rows' or 'Columns')"),
+    method: z
+      .string()
+      .optional()
+      .describe("Sort method for Chinese characters ('PinYin' or 'StrokeCount')"),
+  },
+  async ({ worksheet, range, sortFields, matchCase, hasHeaders, orientation, method }) => {
+    const body = {
+      fields: sortFields,
+    };
+
+    if (matchCase !== undefined) body.matchCase = matchCase;
+    if (hasHeaders !== undefined) body.hasHeaders = hasHeaders;
+    if (orientation) body.orientation = orientation;
+    if (method) body.method = method;
+
+    return graphRequest(
+      `/workbook/worksheets('${worksheet}')/range(address='${range}')/sort/apply`,
+      {
+        method: 'POST',
+        body: JSON.stringify(body),
+      }
+    );
+  }
+);
+
+server.tool(
+  'create-table',
+  {
+    worksheet: z.string().default('Sheet1').describe('Worksheet name'),
+    range: z.string().describe("Range address (e.g., 'A1:B5')"),
+    hasHeaders: z.boolean().optional().describe('Whether the range has headers'),
+    tableName: z.string().optional().describe('Name for the new table'),
+  },
+  async ({ worksheet, range, hasHeaders = true, tableName }) => {
+    const body = {
+      address: range,
+      hasHeaders,
+    };
+
+    if (tableName) {
+      body.name = tableName;
+    }
+
+    return graphRequest(`/workbook/worksheets('${worksheet}')/tables/add`, {
+      method: 'POST',
+      body: JSON.stringify(body),
+    });
+  }
+);
+
+server.tool(
+  'get-range',
+  {
+    worksheet: z.string().default('Sheet1').describe('Worksheet name'),
+    range: z.string().describe("Range address (e.g., 'A1:B5')"),
+  },
+  async ({ worksheet, range }) => {
+    return graphRequest(`/workbook/worksheets('${worksheet}')/range(address='${range}')`, {
+      method: 'GET',
+    });
+  }
+);
+
+server.tool('list-worksheets', {}, async () => {
+  return graphRequest('/workbook/worksheets', {
+    method: 'GET',
+  });
+});
+
+server.tool('close-session', {}, async () => {
+  if (!sessionId) {
+    return {
+      content: [
+        {
+          type: 'text',
+          text: JSON.stringify({ message: 'No active session' }),
+        },
+      ],
+    };
+  }
+
+  try {
+    const accessToken = await 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) {
+      sessionId = null;
+      return {
+        content: [
+          {
+            type: 'text',
+            text: JSON.stringify({ message: 'Session 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' }),
+        },
+      ],
+    };
+  }
+});
+
+server.tool(
+  'delete-chart',
+  {
+    worksheet: z.string().default('Sheet1').describe('Worksheet name'),
+    chartName: z.string().describe('The name of the chart to delete'),
+  },
+  async ({ worksheet, chartName }) => {
+    return graphRequest(`/workbook/worksheets('${worksheet}')/charts('${chartName}')`, {
+      method: 'DELETE',
+    });
+  }
+);
+
+server.tool(
+  'get-charts',
+  {
+    worksheet: z.string().default('Sheet1').describe('Worksheet name'),
+  },
+  async ({ worksheet }) => {
+    return graphRequest(`/workbook/worksheets('${worksheet}')/charts`, {
+      method: 'GET',
+    });
+  }
+);
+
+async function main() {
+  try {
+    if (args.v) {
+      enableConsoleLogging();
+    }
+
+    logger.info('Microsoft 365 MCP Server starting...');
+
+    if (args.login) {
+      await authManager.acquireTokenByDeviceCode();
+      logger.info('Login completed, proceeding with session creation');
+      process.exit();
+    }
+
+    if (args.testLogin) {
+      try {
+        logger.info('Testing login...');
+        const token = await authManager.getToken();
+        if (token) {
+          logger.info('Login test successful');
+
+          console.log(JSON.stringify({ success: true, message: 'Login successful' }));
+        } else {
+          logger.error('Login test failed - no token received');
+          console.log(
+            JSON.stringify({ success: false, message: 'Login failed - no token received' })
+          );
+        }
+      } catch (error) {
+        logger.error(`Login test failed: ${error.message}`);
+        console.log(JSON.stringify({ success: false, message: `Login failed: ${error.message}` }));
+      }
+      process.exit(0);
+    }
+
+    await createSession();
+
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+  } catch (error) {
+    logger.error(`Startup error: ${error}`);
+    process.exit(1);
+  }
+}
+
+main();

package/logger.mjs

@@ -0,0 +1,44 @@
+import winston from 'winston';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+const logsDir = path.join(__dirname, 'logs');
+import fs from 'fs';
+
+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/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@softeria/ms-365-mcp-server",
+  "version": "0.1.9",
+  "description": "Microsoft 365 MCP Server",
+  "type": "module",
+  "main": "index.mjs",
+  "bin": {
+    "ms-365-mcp-server": "index.mjs"
+  },
+  "scripts": {
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "start": "node index.mjs",
+    "format": "prettier --write \"**/*.{js,mjs,json,md}\"",
+    "release": "node bin/release.mjs"
+  },
+  "keywords": [
+    "microsoft",
+    "365",
+    "mcp",
+    "server"
+  ],
+  "author": "",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@azure/msal-node": "^2.1.0",
+    "@modelcontextprotocol/sdk": "^1.8.0",
+    "commander": "^11.1.0",
+    "keytar": "^7.9.0",
+    "winston": "^3.17.0",
+    "zod": "^3.24.2"
+  },
+  "devDependencies": {
+    "prettier": "^3.5.3",
+    "vitest": "^3.1.1"
+  }
+}

package/test/cli.test.js

@@ -0,0 +1,46 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+vi.mock('commander', () => {
+  const mockCommand = {
+    name: vi.fn().mockReturnThis(),
+    description: vi.fn().mockReturnThis(),
+    version: vi.fn().mockReturnThis(),
+    option: vi.fn().mockReturnThis(),
+    parse: vi.fn(),
+    opts: vi.fn().mockReturnValue({ file: 'test.xlsx' }),
+  };
+
+  return {
+    Command: vi.fn(() => mockCommand),
+  };
+});
+
+vi.mock('../auth.mjs', () => {
+  return {
+    default: vi.fn().mockImplementation(() => ({
+      getToken: vi.fn().mockResolvedValue('mock-token'),
+      logout: vi.fn().mockResolvedValue(true),
+    })),
+  };
+});
+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(() => {
+    vi.clearAllMocks();
+  });
+
+  afterEach(() => {
+    vi.resetAllMocks();
+  });
+
+  describe('parseArgs', () => {
+    it('should return command options', () => {
+      const result = parseArgs();
+      expect(result).toEqual({ file: 'test.xlsx' });
+    });
+  });
+});

package/test/graph-api.test.js

@@ -0,0 +1,88 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+global.fetch = vi.fn();
+
+describe('Graph API Functions', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    global.fetch.mockImplementation(async () => ({
+      ok: true,
+      status: 200,
+      json: async () => ({ value: 'test data' }),
+      text: async () => 'Error text',
+    }));
+  });
+
+  afterEach(() => {
+    vi.resetAllMocks();
+  });
+
+  describe('createSession', () => {
+    async function createSession(filePath, token) {
+      try {
+        const response = await fetch(
+          `https://graph.microsoft.com/v1.0/me/drive/root:${filePath}:/workbook/createSession`,
+          {
+            method: 'POST',
+            headers: {
+              Authorization: `Bearer ${token}`,
+              'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({ persistChanges: true }),
+          }
+        );
+
+        if (!response.ok) {
+          return null;
+        }
+
+        const result = await response.json();
+        return result.id;
+      } catch (error) {
+        return null;
+      }
+    }
+
+    it('should create a session successfully', async () => {
+      global.fetch.mockImplementationOnce(async () => ({
+        ok: true,
+        status: 200,
+        json: async () => ({ id: 'session-123' }),
+      }));
+
+      const result = await createSession('/test.xlsx', 'mock-token');
+
+      expect(result).toBe('session-123');
+      expect(global.fetch).toHaveBeenCalledWith(
+        'https://graph.microsoft.com/v1.0/me/drive/root:/test.xlsx:/workbook/createSession',
+        expect.objectContaining({
+          method: 'POST',
+          headers: expect.objectContaining({
+            Authorization: 'Bearer mock-token',
+          }),
+        })
+      );
+    });
+
+    it('should return null if session creation fails', async () => {
+      global.fetch.mockImplementationOnce(async () => ({
+        ok: false,
+        status: 400,
+        text: async () => 'Bad request',
+      }));
+
+      const result = await createSession('/test.xlsx', 'mock-token');
+
+      expect(result).toBeNull();
+    });
+
+    it('should return null if an error is thrown', async () => {
+      global.fetch.mockImplementationOnce(() => {
+        throw new Error('Network error');
+      });
+
+      const result = await createSession('/test.xlsx', 'mock-token');
+
+      expect(result).toBeNull();
+    });
+  });
+});

package/test/integration.test.js

@@ -0,0 +1,40 @@
+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/mcp-server.test.js

@@ -0,0 +1,37 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { z } from 'zod';
+
+vi.mock('@modelcontextprotocol/sdk/server/mcp.js', () => ({
+  McpServer: vi.fn(() => ({
+    tool: vi.fn(),
+    connect: vi.fn().mockResolvedValue(undefined),
+    name: 'TestServer',
+    version: '0.1.1',
+  })),
+}));
+vi.spyOn(process.stderr, 'write').mockImplementation(() => true);
+
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+
+describe('MCP Server', () => {
+  let server;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    server = new McpServer();
+  });
+
+  it('should be created with proper configuration', () => {
+    expect(McpServer).toHaveBeenCalled();
+    expect(server).toBeDefined();
+  });
+
+  it('should be able to register tools', () => {
+    server.tool('test-tool', { param: z.string() }, async () => {});
+    expect(server.tool).toHaveBeenCalledWith(
+      'test-tool',
+      { param: expect.any(Object) },
+      expect.any(Function)
+    );
+  });
+});

package/test/simple.test.js

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

package/vitest.config.js

@@ -0,0 +1,8 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: 'node',
+  },
+});