@frustrated/ms-graph-mcp 0.1.8 → 0.1.11

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.11");
+
+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,142 @@
-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';
+import * as onedrive from './tools/onedrive.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.11',
+  });
+
+  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) }] };
+      },
+    );
+  }
+
+  if (isToolEnabled('onedrive.list_items')) {
+    server.tool(
+      'onedrive.list_items',
+      'List files and folders from OneDrive root or a specific folder',
+      {
+        folderPath: z.string().trim().optional().describe('Folder path relative to OneDrive root, e.g. /Projects'),
+        itemId: z.string().trim().optional().describe('Drive item ID to list children from'),
+        top: z.number().int().min(1).max(999).optional().describe('Maximum number of items to return'),
+        select: z.string().trim().optional().describe('Optional OData $select clause'),
+      },
+      async (input) => {
+        const token = await getAccessToken();
+        const result = await onedrive.listItems(buildGraphClient(token), input);
+        return { content: [{ type: 'text' as const, text: JSON.stringify(result, null, 2) }] };
+      },
+    );
+  }
+
+  if (isToolEnabled('onedrive.get_item')) {
+    server.tool(
+      'onedrive.get_item',
+      'Get metadata for a OneDrive file or folder by path or item ID',
+      {
+        path: z.string().trim().optional().describe('Item path relative to OneDrive root, e.g. /Projects/report.docx'),
+        itemId: z.string().trim().optional().describe('Drive item ID'),
+        select: z.string().trim().optional().describe('Optional OData $select clause'),
+      },
+      async (input) => {
+        const token = await getAccessToken();
+        const result = await onedrive.getItem(buildGraphClient(token), input);
+        return { content: [{ type: 'text' as const, text: JSON.stringify(result, null, 2) }] };
+      },
+    );
+  }
+
+  if (isToolEnabled('onedrive.search_items')) {
+    server.tool(
+      'onedrive.search_items',
+      'Search OneDrive for files and folders',
+      {
+        query: z.string().trim().min(1).describe('Search query'),
+        top: z.number().int().min(1).max(999).optional().describe('Maximum number of items to return'),
+        select: z.string().trim().optional().describe('Optional OData $select clause'),
+      },
+      async (input) => {
+        const token = await getAccessToken();
+        const result = await onedrive.searchItems(buildGraphClient(token), input);
+        return { content: [{ type: 'text' as const, text: JSON.stringify(result, null, 2) }] };
+      },
+    );
+  }
+
+  if (isToolEnabled('onedrive.create_folder')) {
+    server.tool(
+      'onedrive.create_folder',
+      'Create a folder in OneDrive root or under a specific parent',
+      {
+        name: z.string().trim().min(1).describe('Folder name'),
+        parentPath: z.string().trim().optional().describe('Parent folder path relative to OneDrive root'),
+        parentItemId: z.string().trim().optional().describe('Parent drive item ID'),
+      },
+      async (input) => {
+        const token = await getAccessToken();
+        const result = await onedrive.createFolder(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,56 @@
-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, describeGraphError } from '../utils.ts';
+
+function assertValidEventTimeRange(start: { dateTime: string; timeZone: string }, end: { dateTime: string; timeZone: string }): void {
+  const startDate = new Date(start.dateTime);
+  const endDate = new Date(end.dateTime);
+
+  if (Number.isNaN(startDate.getTime())) {
+    throw new Error(`Invalid start.dateTime value: ${start.dateTime}`);
+  }
+  if (Number.isNaN(endDate.getTime())) {
+    throw new Error(`Invalid end.dateTime value: ${end.dateTime}`);
+  }
+  if (endDate.getTime() <= startDate.getTime()) {
+    throw new Error('Event end time must be after the start time.');
+  }
+  if (!start.timeZone.trim() || !end.timeZone.trim()) {
+    throw new Error('Both start.timeZone and end.timeZone are required.');
+  }
+}
+
+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 {
+    assertValidEventTimeRange(input.start, input.end);
+
+    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);
+    throw new Error(`Failed to create calendar event: ${describeGraphError(err)}`);
+  }
+}

package/src/tools/index.ts

@@ -1,9 +1,12 @@
-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.ts';
+
+export const tools = {
+  'mail.list_messages': mail.listMessages,
+  'calendar.create_event': calendar.createEvent,
+  'onedrive.list_items': onedrive.listItems,
+  'onedrive.get_item': onedrive.getItem,
+  'onedrive.search_items': onedrive.searchItems,
+  'onedrive.create_folder': onedrive.createFolder,
+};

package/src/tools/mail.ts

@@ -1,34 +1,60 @@
-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, describeGraphError } from '../utils.ts';
+
+const WELL_KNOWN_FOLDERS = new Map<string, string>([
+  ['inbox', 'inbox'],
+  ['sent', 'sentitems'],
+  ['sentitems', 'sentitems'],
+  ['drafts', 'drafts'],
+  ['deleted', 'deleteditems'],
+  ['deleteditems', 'deleteditems'],
+  ['archive', 'archive'],
+  ['junk', 'junkemail'],
+  ['junkemail', 'junkemail'],
+  ['outbox', 'outbox'],
+]);
+
+function normalizeFolderId(folderId?: string): string | undefined {
+  if (!folderId) {
+    return undefined;
+  }
+
+  const trimmed = folderId.trim();
+  if (!trimmed) {
+    return undefined;
+  }
+
+  return WELL_KNOWN_FOLDERS.get(trimmed.toLowerCase()) ?? trimmed;
+}
+
+export async function listMessages(graphClient: Client, input: { folderId?: string; top?: number; filter?: string }): Promise<any> {
+  try {
+    const folderId = normalizeFolderId(input.folderId);
+    let request = graphClient.api(folderId ? `/me/mailFolders/${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 new Error(`Failed to list messages: ${describeGraphError(err)}`);
+  }
+}