@frustrated/ms-graph-mcp 0.1.8 → 0.1.10

package/src/config.ts

@@ -1,48 +1,52 @@
-import { promises as fs } from "node:fs";
-import * as path from "node:path";
-import * as os from "node:os";
-
-const CONFIG_DIR = path.join(os.homedir(), ".ms-graph-mcp");
-const CONFIG_FILE = path.join(CONFIG_DIR, "config.json");
-
-interface AppConfig {
-  clientId: string;
-  tenantId: string;
-  enabledTools: string[]; // List of tool names that are enabled
-}
-
-let appConfig: AppConfig = {
-  clientId: "0a74e52a-4d5b-4005-8dad-6b7cf45ec5fe", // Default centralized client ID
-  tenantId: "common",
-  enabledTools: [],
-};
-
-export async function loadConfig(): Promise<AppConfig> {
-  try {
-    const configContent = await fs.readFile(CONFIG_FILE, "utf-8");
-    appConfig = { ...appConfig, ...JSON.parse(configContent) };
-  } catch (error) {
-    // If file doesn't exist or is invalid, use default config
-    console.warn(
-      "No existing config found or config file is invalid. Using default configuration.",
-    );
-  }
-  return appConfig;
-}
-
-export async function saveConfig(newConfig: Partial<AppConfig>): Promise<void> {
-  appConfig = { ...appConfig, ...newConfig };
-  await fs.mkdir(CONFIG_DIR, { recursive: true });
-  await fs.writeFile(CONFIG_FILE, JSON.stringify(appConfig, null, 2));
-}
-
-export function getConfig(): AppConfig {
-  return appConfig;
-}
-
-export function isToolEnabled(toolName: string): boolean {
-  return appConfig.enabledTools.includes(toolName);
-}
-
-// Initialize config on module load
-loadConfig();
+import { promises as fs } from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
+
+const CONFIG_DIR = path.join(os.homedir(), ".ms-graph-mcp");
+const CONFIG_FILE = path.join(CONFIG_DIR, "config.json");
+
+interface AppConfig {
+  clientId: string;
+  tenantId: string;
+  enabledTools: string[]; // List of tool names that are enabled
+}
+
+let appConfig: AppConfig = {
+  clientId: "0a74e52a-4d5b-4005-8dad-6b7cf45ec5fe", // Default centralized client ID
+  tenantId: "common",
+  enabledTools: [],
+};
+
+export async function loadConfig(): Promise<AppConfig> {
+  try {
+    const configContent = await fs.readFile(CONFIG_FILE, "utf-8");
+    appConfig = { ...appConfig, ...JSON.parse(configContent) };
+  } catch (error) {
+    // If file doesn't exist or is invalid, use default config
+    console.warn(
+      "No existing config found or config file is invalid. Using default configuration.",
+    );
+  }
+  return appConfig;
+}
+
+export async function saveConfig(newConfig: Partial<AppConfig>): Promise<void> {
+  appConfig = { ...appConfig, ...newConfig };
+  await fs.mkdir(CONFIG_DIR, { recursive: true });
+  await fs.writeFile(CONFIG_FILE, JSON.stringify(appConfig, null, 2));
+}
+
+export function getConfig(): AppConfig {
+  return appConfig;
+}
+
+export function isToolEnabled(toolName: string): boolean {
+  // Empty enabledTools means all tools are enabled (no explicit restriction)
+  if (appConfig.enabledTools.length === 0) {
+    return true;
+  }
+  return appConfig.enabledTools.includes(toolName);
+}
+
+// Initialize config on module load
+loadConfig();

package/src/index.ts

@@ -1,80 +1,77 @@
-#!/usr/bin/env node
-import { Command } from "@commander-js/extra-typings";
-import { initAuth, revokeAuth, getAuthStatus } from "./auth.ts";
-import { getConfig, saveConfig } from "./config.ts";
-import { startMcpServer } from "./mcp-interface.ts";
-
-const program = new Command();
-
-program
-  .name("ms-graph-mcp")
-  .description("CLI for JSR-based Microsoft Graph MCP package")
-  .version("0.1.0");
-
-program
-  .command("init")
-  .description("Initialize authentication with Microsoft Graph")
-  .action(async () => {
-    try {
-      await initAuth();
-      console.log("Authentication process completed.");
-    } catch (error) {
-      console.error("Authentication failed:", error instanceof Error ? error.message : String(error));
-      process.exit(1);
-    }
-  });
-
-program
-  .command("revoke")
-  .description("Revoke Microsoft Graph authentication and clear tokens")
-  .action(async () => {
-    try {
-      await revokeAuth();
-      console.log("Authentication revoked successfully.");
-    } catch (error) {
-      console.error("Failed to revoke authentication:", error instanceof Error ? error.message : String(error));
-      process.exit(1);
-    }
-  });
-
-program
-  .command("permissions")
-  .description(
-    "Display current authentication status and configured permissions",
-  )
-  .action(async () => {
-    try {
-      const authStatus = await getAuthStatus();
-      const config = getConfig();
-      console.log("--- Microsoft Graph MCP Status ---");
-      console.log(`Client ID: ${authStatus.clientId}`);
-      console.log(`Tenant ID: ${authStatus.tenantId}`);
-      console.log(
-        `Authenticated: ${authStatus.isAuthenticated ? "Yes" : "No"}`,
-      );
-      console.log("\nEnabled Tools:");
-      if (config.enabledTools.length > 0) {
-        config.enabledTools.forEach((tool) => console.log(`- ${tool}`));
-      } else {
-        console.log(
-          "No specific tools are explicitly enabled in config. All available tools will be used.",
-        );
-      }
-      console.log("----------------------------------");
-    } catch (error) {
-      console.error("Failed to retrieve status:", error instanceof Error ? error.message : String(error));
-      process.exit(1);
-    }
-  });
-
-program
-  .command("run")
-  .description("Start the MCP server to listen for commands via stdin/stdout")
-  .action(async () => {
-    console.log("MCP server started. Listening for commands on stdin...");
-    // Placeholder for MCP interface logic
-    // This will be implemented in src/mcp-interface.ts and called here
-    startMcpServer();
-  });
-
-program.parse(process.argv);
+#!/usr/bin/env node
+import { Command } from "@commander-js/extra-typings";
+import { initAuth, revokeAuth, getAuthStatus } from "./auth.ts";
+import { getConfig, saveConfig } from "./config.ts";
+import { startMcpServer } from "./mcp-interface.ts";
+
+const program = new Command();
+
+program
+  .name("ms-graph-mcp")
+  .description("CLI for JSR-based Microsoft Graph MCP package")
+  .version("0.1.0");
+
+program
+  .command("init")
+  .description("Initialize authentication with Microsoft Graph")
+  .action(async () => {
+    try {
+      await initAuth();
+      console.log("Authentication process completed.");
+    } catch (error) {
+      console.error("Authentication failed:", error instanceof Error ? error.message : String(error));
+      process.exit(1);
+    }
+  });
+
+program
+  .command("revoke")
+  .description("Revoke Microsoft Graph authentication and clear tokens")
+  .action(async () => {
+    try {
+      await revokeAuth();
+      console.log("Authentication revoked successfully.");
+    } catch (error) {
+      console.error("Failed to revoke authentication:", error instanceof Error ? error.message : String(error));
+      process.exit(1);
+    }
+  });
+
+program
+  .command("permissions")
+  .description(
+    "Display current authentication status and configured permissions",
+  )
+  .action(async () => {
+    try {
+      const authStatus = await getAuthStatus();
+      const config = getConfig();
+      console.log("--- Microsoft Graph MCP Status ---");
+      console.log(`Client ID: ${authStatus.clientId}`);
+      console.log(`Tenant ID: ${authStatus.tenantId}`);
+      console.log(
+        `Authenticated: ${authStatus.isAuthenticated ? "Yes" : "No"}`,
+      );
+      console.log("\nEnabled Tools:");
+      if (config.enabledTools.length > 0) {
+        config.enabledTools.forEach((tool) => console.log(`- ${tool}`));
+      } else {
+        console.log(
+          "No specific tools are explicitly enabled in config. All available tools will be used.",
+        );
+      }
+      console.log("----------------------------------");
+    } catch (error) {
+      console.error("Failed to retrieve status:", error instanceof Error ? error.message : String(error));
+      process.exit(1);
+    }
+  });
+
+program
+  .command("run")
+  .description("Start the MCP server to listen for commands via stdin/stdout")
+  .action(async () => {
+    await startMcpServer();
+  });
+
+program.parse(process.argv);

package/src/mcp-interface.ts

@@ -1,122 +1,72 @@
-import { getAccessToken } from './auth.ts';
-import { getConfig, isToolEnabled } from './config.ts';
-import { error, log } from './utils.ts';
-import { Client } from '@microsoft/microsoft-graph-client';
-
-// Define MCP message interfaces
-interface McpRequest {
-  type: 'request';
-  id: string;
-  tool: string;
-  input: any;
-}
-
-interface McpResponse {
-  type: 'response';
-  id: string;
-  status: 'success' | 'error';
-  output?: any;
-  error?: { code: string; message: string };
-}
-
-// Placeholder for registered tools
-import { tools as registeredTools } from './tools/index.ts';
-
-
-async function processMcpRequest(request: McpRequest): Promise<McpResponse> {
-  const config = getConfig();
-
-  if (!isToolEnabled(request.tool)) {
-    return {
-      type: 'response',
-      id: request.id,
-      status: 'error',
-      error: { code: 'TOOL_DISABLED', message: `Tool '${request.tool}' is disabled.` },
-    };
-  }
-
-  const toolHandler = (registeredTools as Record<string, ((graphClient: Client, input: any) => Promise<any>) | undefined>)[request.tool];
-  if (!toolHandler) {
-    return {
-      type: 'response',
-      id: request.id,
-      status: 'error',
-      error: { code: 'TOOL_NOT_FOUND', message: `Tool '${request.tool}' not found.` },
-    };
-  }
-
-  try {
-    const accessToken = await getAccessToken();
-    const graphClient = Client.init({
-      authProvider: (done) => {
-        done(null, accessToken);
-      },
-    });
-
-    const output = await toolHandler(graphClient, request.input);
-    return {
-      type: 'response',
-      id: request.id,
-      status: 'success',
-      output,
-    };
-  } catch (err: any) {
-    error(`Error executing tool '${request.tool}':`, err);
-    return {
-      type: 'response',
-      id: request.id,
-      status: 'error',
-      error: { code: err.code || 'TOOL_EXECUTION_ERROR', message: err.message || 'An unknown error occurred.' },
-    };
-  }
-}
-
-export function startMcpServer() {
-  log('MCP server started. Listening for commands on stdin...');
-
-  process.stdin.setEncoding('utf8');
-
-  let buffer = '';
-  process.stdin.on('data', async (chunk) => {
-    buffer += chunk;
-    let newlineIndex;
-    while ((newlineIndex = buffer.indexOf('\n')) !== -1) {
-      const line = buffer.substring(0, newlineIndex).trim();
-      buffer = buffer.substring(newlineIndex + 1);
-
-      if (line) {
-        try {
-          const request: McpRequest = JSON.parse(line);
-          if (request.type === 'request' && request.id && request.tool) {
-            const response = await processMcpRequest(request);
-            process.stdout.write(JSON.stringify(response) + '\n');
-          } else {
-            error('Invalid MCP request format:', new Error(line));
-            process.stdout.write(JSON.stringify({
-              type: 'response',
-              id: request.id || 'unknown',
-              status: 'error',
-              error: { code: 'INVALID_REQUEST', message: 'Invalid MCP request format.' },
-            }) + '\n');
-          }
-        } catch (parseError: any) {
-          error('Failed to parse stdin input as JSON:', parseError);
-          process.stdout.write(JSON.stringify({
-            type: 'response',
-            id: 'unknown',
-            status: 'error',
-            error: { code: 'JSON_PARSE_ERROR', message: 'Invalid JSON input.' },
-          }) + '\n');
-        }
-      }
-    }
-  });
-
-  process.stdin.on('end', () => {
-    log('Stdin closed. MCP server shutting down.');
-  });
-
-  process.stdin.on('error', (err) => {
-    error('Stdin error:', err);
-  });
-}
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { z } from 'zod';
+import { getAccessToken } from './auth.ts';
+import { isToolEnabled } from './config.ts';
+import { log } from './utils.ts';
+import { Client } from '@microsoft/microsoft-graph-client';
+import * as mail from './tools/mail.ts';
+import * as calendar from './tools/calendar.ts';
+
+function buildGraphClient(accessToken: string): Client {
+  return Client.init({
+    authProvider: (done) => done(null, accessToken),
+  });
+}
+
+export async function startMcpServer(): Promise<void> {
+  const server = new McpServer({
+    name: 'ms-graph-mcp',
+    version: '0.1.10',
+  });
+
+  if (isToolEnabled('mail.list_messages')) {
+    server.tool(
+      'mail.list_messages',
+      'List email messages from the signed-in user\'s mailbox',
+      {
+        folderId: z.string().optional().describe('Mail folder ID (defaults to Inbox)'),
+        top: z.number().int().min(1).optional().describe('Maximum number of messages to return'),
+        filter: z.string().optional().describe('OData $filter expression'),
+      },
+      async ({ folderId, top, filter }) => {
+        const token = await getAccessToken();
+        const result = await mail.listMessages(buildGraphClient(token), { folderId, top, filter });
+        return { content: [{ type: 'text' as const, text: JSON.stringify(result, null, 2) }] };
+      },
+    );
+  }
+
+  if (isToolEnabled('calendar.create_event')) {
+    server.tool(
+      'calendar.create_event',
+      'Create a new event in the signed-in user\'s calendar',
+      {
+        subject: z.string().describe('Event title'),
+        start: z.object({
+          dateTime: z.string().describe('ISO 8601 date-time string'),
+          timeZone: z.string().describe('IANA timezone name, e.g. "America/New_York"'),
+        }),
+        end: z.object({
+          dateTime: z.string().describe('ISO 8601 date-time string'),
+          timeZone: z.string().describe('IANA timezone name'),
+        }),
+        content: z.string().optional().describe('HTML body of the event'),
+        attendees: z.array(z.object({
+          emailAddress: z.string().email(),
+          type: z.enum(['required', 'optional']),
+        })).optional().describe('List of attendees'),
+        location: z.string().optional().describe('Event location display name'),
+      },
+      async (input) => {
+        const token = await getAccessToken();
+        const result = await calendar.createEvent(buildGraphClient(token), input);
+        return { content: [{ type: 'text' as const, text: JSON.stringify(result, null, 2) }] };
+      },
+    );
+  }
+
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  log('MCP server started (JSON-RPC 2.0 over stdio). Listening for commands...');
+}

package/src/tools/calendar.ts

@@ -1,41 +1,41 @@
-import { Client } from '@microsoft/microsoft-graph-client';
-import { log, error } from '../utils.ts';
-
-export async function createEvent(graphClient: Client, input: {
-  subject: string;
-  start: { dateTime: string; timeZone: string };
-  end: { dateTime: string; timeZone: string };
-  content?: string;
-  attendees?: Array<{ emailAddress: string; type: 'required' | 'optional' }>;
-  location?: string;
-}): Promise<any> {
-  try {
-    const event = {
-      subject: input.subject,
-      start: input.start,
-      end: input.end,
-      body: input.content ? { contentType: 'HTML', content: input.content } : undefined,
-      attendees: input.attendees?.map(att => ({
-        emailAddress: { address: att.emailAddress },
-        type: att.type,
-      })),
-      location: input.location ? { displayName: input.location } : undefined,
-    };
-
-    const response = await graphClient.api('/me/events').post(event);
-    log(`Created calendar event: ${response.subject} (ID: ${response.id})`);
-    return {
-      id: response.id,
-      webLink: response.webLink,
-      status: 'created',
-    };
-  } catch (err: any) {
-    error('Error creating calendar event:', err);
-    return {
-      id: null,
-      webLink: null,
-      status: 'failed',
-      errorMessage: err.message,
-    };
-  }
-}
+import { Client } from '@microsoft/microsoft-graph-client';
+import { log, error } from '../utils.ts';
+
+export async function createEvent(graphClient: Client, input: {
+  subject: string;
+  start: { dateTime: string; timeZone: string };
+  end: { dateTime: string; timeZone: string };
+  content?: string;
+  attendees?: Array<{ emailAddress: string; type: 'required' | 'optional' }>;
+  location?: string;
+}): Promise<any> {
+  try {
+    const event = {
+      subject: input.subject,
+      start: input.start,
+      end: input.end,
+      body: input.content ? { contentType: 'HTML', content: input.content } : undefined,
+      attendees: input.attendees?.map(att => ({
+        emailAddress: { address: att.emailAddress },
+        type: att.type,
+      })),
+      location: input.location ? { displayName: input.location } : undefined,
+    };
+
+    const response = await graphClient.api('/me/events').post(event);
+    log(`Created calendar event: ${response.subject} (ID: ${response.id})`);
+    return {
+      id: response.id,
+      webLink: response.webLink,
+      status: 'created',
+    };
+  } catch (err: any) {
+    error('Error creating calendar event:', err);
+    return {
+      id: null,
+      webLink: null,
+      status: 'failed',
+      errorMessage: err.message,
+    };
+  }
+}

package/src/tools/index.ts

@@ -1,9 +1,9 @@
-import * as mail from './mail.ts';
-import * as calendar from './calendar.ts';
-// import * as onedrive from './onedrive'; // Placeholder for future tools
-
-export const tools = {
-  'mail.list_messages': mail.listMessages,
-  'calendar.create_event': calendar.createEvent,
-  // 'onedrive.list_files': onedrive.listFiles,
-};
+import * as mail from './mail.ts';
+import * as calendar from './calendar.ts';
+// import * as onedrive from './onedrive'; // Placeholder for future tools
+
+export const tools = {
+  'mail.list_messages': mail.listMessages,
+  'calendar.create_event': calendar.createEvent,
+  // 'onedrive.list_files': onedrive.listFiles,
+};

package/src/tools/mail.ts

@@ -1,34 +1,34 @@
-import { Client } from '@microsoft/microsoft-graph-client';
-import { log, error } from '../utils.ts';
-
-export async function listMessages(graphClient: Client, input: { folderId?: string; top?: number; filter?: string }): Promise<any> {
-  try {
-    let request = graphClient.api(input.folderId ? `/me/mailFolders/${input.folderId}/messages` : 
-'/me/messages');
-
-    if (input.top) {
-      request = request.top(input.top);
-    }
-    if (input.filter) {
-      request = request.filter(input.filter);
-    }
-
-    const response = await request.select('id,subject,from,receivedDateTime,isRead,bodyPreview,webLink').get();
-    log(`Listed ${response.value.length} messages.`);
-    return {
-      messages: response.value.map((msg: any) => ({
-        id: msg.id,
-        subject: msg.subject,
-        from: msg.from,
-        receivedDateTime: msg.receivedDateTime,
-        isRead: msg.isRead,
-        bodyPreview: msg.bodyPreview,
-        webLink: msg.webLink,
-      })),
-      nextLink: response['@odata.nextLink'],
-    };
-  } catch (err: any) {
-    error('Error listing messages:', err);
-    throw err;
-  }
-}
+import { Client } from '@microsoft/microsoft-graph-client';
+import { log, error } from '../utils.ts';
+
+export async function listMessages(graphClient: Client, input: { folderId?: string; top?: number; filter?: string }): Promise<any> {
+  try {
+    let request = graphClient.api(input.folderId ? `/me/mailFolders/${input.folderId}/messages` : 
+'/me/messages');
+
+    if (input.top) {
+      request = request.top(input.top);
+    }
+    if (input.filter) {
+      request = request.filter(input.filter);
+    }
+
+    const response = await request.select('id,subject,from,receivedDateTime,isRead,bodyPreview,webLink').get();
+    log(`Listed ${response.value.length} messages.`);
+    return {
+      messages: response.value.map((msg: any) => ({
+        id: msg.id,
+        subject: msg.subject,
+        from: msg.from,
+        receivedDateTime: msg.receivedDateTime,
+        isRead: msg.isRead,
+        bodyPreview: msg.bodyPreview,
+        webLink: msg.webLink,
+      })),
+      nextLink: response['@odata.nextLink'],
+    };
+  } catch (err: any) {
+    error('Error listing messages:', err);
+    throw err;
+  }
+}