@dashflow/ms365-mcp-server 1.0.0

package/bin/generate-graph-client.mjs

@@ -0,0 +1,59 @@
+#!/usr/bin/env node
+
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { downloadGraphOpenAPI } from './modules/download-openapi.mjs';
+import { generateMcpTools } from './modules/generate-mcp-tools.mjs';
+import { createAndSaveSimplifiedOpenAPI } from './modules/simplified-openapi.mjs';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const rootDir = path.resolve(__dirname, '..');
+const openapiDir = path.join(rootDir, 'openapi');
+const srcDir = path.join(rootDir, 'src');
+
+const openapiFile = path.join(openapiDir, 'openapi.yaml');
+const openapiTrimmedFile = path.join(openapiDir, 'openapi-trimmed.yaml');
+const endpointsFile = path.join(srcDir, 'endpoints.json');
+
+const generatedDir = path.join(srcDir, 'generated');
+
+const args = process.argv.slice(2);
+const forceDownload = args.includes('--force');
+
+async function main() {
+  console.log('Microsoft Graph API OpenAPI Processor');
+  console.log('------------------------------------');
+
+  try {
+    console.log('\n📥 Step 1: Downloading OpenAPI specification');
+    const downloaded = await downloadGraphOpenAPI(
+      openapiDir,
+      openapiFile,
+      undefined,
+      forceDownload
+    );
+
+    if (downloaded) {
+      console.log('\n✅ OpenAPI specification successfully downloaded');
+    } else {
+      console.log('\n⏭️ Download skipped (file exists)');
+    }
+
+    console.log('\n🔧 Step 2: Creating simplified OpenAPI specification');
+    createAndSaveSimplifiedOpenAPI(endpointsFile, openapiFile, openapiTrimmedFile);
+    console.log('✅ Successfully created simplified OpenAPI specification');
+
+    console.log('\n🚀 Step 3: Generating client code using openapi-zod-client');
+    generateMcpTools(null, generatedDir);
+    console.log('✅ Successfully generated client code');
+  } catch (error) {
+    console.error('\n❌ Error processing OpenAPI specification:', error.message);
+    process.exit(1);
+  }
+}
+
+main().catch((error) => {
+  console.error('Fatal error:', error);
+  process.exit(1);
+});

package/bin/modules/download-openapi.mjs

@@ -0,0 +1,40 @@
+import fs from 'fs';
+
+const DEFAULT_OPENAPI_URL =
+  'https://raw.githubusercontent.com/microsoftgraph/msgraph-metadata/refs/heads/master/openapi/v1.0/openapi.yaml';
+
+export async function downloadGraphOpenAPI(
+  targetDir,
+  targetFile,
+  openapiUrl = DEFAULT_OPENAPI_URL,
+  forceDownload = false
+) {
+  if (!fs.existsSync(targetDir)) {
+    console.log(`Creating directory: ${targetDir}`);
+    fs.mkdirSync(targetDir, { recursive: true });
+  }
+
+  if (fs.existsSync(targetFile) && !forceDownload) {
+    console.log(`OpenAPI specification already exists at ${targetFile}`);
+    console.log('Use --force to download again');
+    return false;
+  }
+
+  console.log(`Downloading OpenAPI specification from ${openapiUrl}`);
+
+  try {
+    const response = await fetch(openapiUrl);
+
+    if (!response.ok) {
+      throw new Error(`Failed to download: ${response.status} ${response.statusText}`);
+    }
+
+    const content = await response.text();
+    fs.writeFileSync(targetFile, content);
+    console.log(`OpenAPI specification downloaded to ${targetFile}`);
+    return true;
+  } catch (error) {
+    console.error('Error downloading OpenAPI specification:', error.message);
+    throw error;
+  }
+}

package/bin/modules/extract-descriptions.mjs

@@ -0,0 +1,48 @@
+import fs from 'fs';
+import yaml from 'js-yaml';
+
+export function convertPathToOpenApiFormat(pathPattern) {
+  let path = pathPattern.replace(/\{([^}]+)\}/g, (match, param) => {
+    const normalizedParam = param.replace(/-/g, '_');
+    return `{${normalizedParam}}`;
+  });
+
+  path = path.replace(/\{([^}]+)_id(\d+)\}/g, (match, param, num) => {
+    return `{${param}_id_${num}}`;
+  });
+
+  if (!path.startsWith('/')) {
+    path = '/' + path;
+  }
+
+  return path;
+}
+
+export function extractDescriptions(openapiFile, endpoints) {
+  console.log('Extracting descriptions from OpenAPI spec...');
+
+  const openApiSpec = yaml.load(fs.readFileSync(openapiFile, 'utf8'));
+  const descriptions = {};
+
+  endpoints.forEach((endpoint) => {
+    const path = convertPathToOpenApiFormat(endpoint.pathPattern);
+    const method = endpoint.method.toLowerCase();
+
+    if (openApiSpec.paths && openApiSpec.paths[path] && openApiSpec.paths[path][method]) {
+      const operation = openApiSpec.paths[path][method];
+
+      const description =
+        operation.description || operation.summary || `Operation for ${endpoint.toolName}`;
+
+      descriptions[endpoint.toolName] = description;
+      console.log(
+        `Found description for ${endpoint.toolName}: ${description.substring(0, 50)}${description.length > 50 ? '...' : ''}`
+      );
+    } else {
+      console.warn(`Path ${path} ${method} not found in OpenAPI spec`);
+      descriptions[endpoint.toolName] = `Operation for ${endpoint.toolName}`;
+    }
+  });
+
+  return descriptions;
+}

package/bin/modules/generate-mcp-tools.mjs

@@ -0,0 +1,46 @@
+import fs from 'fs';
+import path from 'path';
+import { execSync } from 'child_process';
+
+export function generateMcpTools(openApiSpec, outputDir) {
+  try {
+    console.log('Generating client code from OpenAPI spec using openapi-zod-client...');
+
+    if (!fs.existsSync(outputDir)) {
+      fs.mkdirSync(outputDir, { recursive: true });
+      console.log(`Created directory: ${outputDir}`);
+    }
+
+    const rootDir = path.resolve(outputDir, '../..');
+    const openapiDir = path.join(rootDir, 'openapi');
+    const openapiTrimmedFile = path.join(openapiDir, 'openapi-trimmed.yaml');
+
+    const clientFilePath = path.join(outputDir, 'client.ts');
+    execSync(
+      `npx -y openapi-zod-client "${openapiTrimmedFile}" -o "${clientFilePath}" --with-description --strict-objects --additional-props-default-value=false`,
+      {
+        stdio: 'inherit',
+      }
+    );
+
+    console.log(`Generated client code at: ${clientFilePath}`);
+
+    let clientCode = fs.readFileSync(clientFilePath, 'utf-8');
+    clientCode = clientCode.replace(/'@zodios\/core';/, "'./hack.js';");
+
+    clientCode = clientCode.replace(
+      /const microsoft_graph_attachment = z\s+\.object\({[\s\S]*?}\)\s+\.strict\(\);/,
+      (match) => match.replace(/\.strict\(\);/, '.passthrough();')
+    );
+
+    console.log('Stripping unused errors arrays from endpoint definitions...');
+    // I didn't make up this crazy regex myself; you know who did. It seems works though.
+    clientCode = clientCode.replace(/,?\s*errors:\s*\[[\s\S]*?],?(?=\s*})/g, '');
+
+    fs.writeFileSync(clientFilePath, clientCode);
+
+    return true;
+  } catch (error) {
+    throw new Error(`Error generating client code: ${error.message}`);
+  }
+}