@joshluedeman/m365-mcp 0.1.0

package/dist/index.js

@@ -0,0 +1,796 @@
+#!/usr/bin/env node
+import {
+  acquireToken,
+  runAuthCommand
+} from "./chunk-JEMHJMEL.js";
+
+// src/index.ts
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// src/server.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+
+// src/tools/tasks/schemas.ts
+import { z } from "zod";
+var ListTasksSchema = {
+  listId: z.string().describe("The ID of the To Do task list"),
+  filter: z.string().optional().describe(`OData $filter expression (e.g. "status eq 'notStarted'")`),
+  top: z.number().int().min(1).max(100).optional().describe("Maximum number of tasks to return (1-100)")
+};
+var GetTaskSchema = {
+  listId: z.string().describe("The ID of the To Do task list"),
+  taskId: z.string().describe("The ID of the task")
+};
+var CreateTaskSchema = {
+  listId: z.string().describe("The ID of the To Do task list"),
+  title: z.string().describe("Task title"),
+  body: z.string().optional().describe("Task body / notes (plain text)"),
+  dueDate: z.string().optional().describe("Due date in ISO 8601 format (e.g. 2026-06-01)"),
+  importance: z.enum(["low", "normal", "high"]).optional().describe("Task importance level")
+};
+var UpdateTaskSchema = {
+  listId: z.string().describe("The ID of the To Do task list"),
+  taskId: z.string().describe("The ID of the task"),
+  title: z.string().optional().describe("Updated task title"),
+  body: z.string().optional().describe("Updated task body / notes"),
+  dueDate: z.string().optional().describe("Updated due date in ISO 8601 format"),
+  importance: z.enum(["low", "normal", "high"]).optional().describe("Updated importance level")
+};
+var CompleteTaskSchema = {
+  listId: z.string().describe("The ID of the To Do task list"),
+  taskId: z.string().describe("The ID of the task to mark complete")
+};
+var DeleteTaskSchema = {
+  listId: z.string().describe("The ID of the To Do task list"),
+  taskId: z.string().describe("The ID of the task to delete")
+};
+
+// src/graph/client.ts
+import { Client } from "@microsoft/microsoft-graph-client";
+function getGraphClient(accessToken) {
+  const authProvider = {
+    getAccessToken: async () => accessToken
+  };
+  return Client.initWithMiddleware({ authProvider });
+}
+
+// src/utils/pagination.ts
+async function collectAllPages(client, url) {
+  const results = [];
+  let nextUrl = url;
+  while (nextUrl !== void 0) {
+    const response = await client.api(nextUrl).get();
+    if (Array.isArray(response.value)) {
+      results.push(...response.value);
+    }
+    nextUrl = response["@odata.nextLink"];
+  }
+  return results;
+}
+
+// src/utils/formatting.ts
+function formatResponse(data) {
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(data, null, 2)
+      }
+    ]
+  };
+}
+function formatError(message) {
+  return {
+    content: [
+      {
+        type: "text",
+        text: message
+      }
+    ],
+    isError: true
+  };
+}
+
+// src/utils/errors.ts
+import { McpError, ErrorCode } from "@modelcontextprotocol/sdk/types.js";
+function parseGraphError(err) {
+  if (err instanceof Error) {
+    const graphErr = err;
+    if (graphErr.statusCode === 429) {
+      let retryAfter = "unknown";
+      try {
+        if (typeof graphErr.body === "string") {
+          const parsed = JSON.parse(graphErr.body);
+          retryAfter = parsed.error?.innerError?.["retry-after"] ?? "unknown";
+        } else if (typeof graphErr.body === "object" && graphErr.body !== null) {
+          retryAfter = graphErr.body.error?.innerError?.["retry-after"] ?? "unknown";
+        }
+      } catch {
+      }
+      return `Graph API rate limit exceeded (429). Retry after ${retryAfter} seconds.`;
+    }
+    if (graphErr.statusCode !== void 0 && graphErr.body !== void 0) {
+      try {
+        const body = typeof graphErr.body === "string" ? JSON.parse(graphErr.body) : graphErr.body;
+        const code = body.error?.code ?? "UnknownError";
+        const message = body.error?.message ?? graphErr.message;
+        return `Graph API error [${graphErr.statusCode}] ${code}: ${message}`;
+      } catch {
+        return `Graph API error [${graphErr.statusCode}]: ${graphErr.message}`;
+      }
+    }
+    return `Error: ${err.message}`;
+  }
+  return `Unexpected error: ${String(err)}`;
+}
+
+// src/tools/tasks/handlers.ts
+async function handleListTaskLists() {
+  try {
+    const token = await acquireToken();
+    const client = getGraphClient(token);
+    const lists = await collectAllPages(client, "/me/todo/lists");
+    return formatResponse(lists);
+  } catch (err) {
+    return formatError(parseGraphError(err));
+  }
+}
+async function handleListTasks(listId, filter, top) {
+  try {
+    const token = await acquireToken();
+    const client = getGraphClient(token);
+    let request = client.api(`/me/todo/lists/${listId}/tasks`);
+    if (filter !== void 0) {
+      request = request.filter(filter);
+    }
+    if (top !== void 0) {
+      request = request.top(top);
+    }
+    const response = await request.get();
+    const tasks = response.value ?? [];
+    if (top === void 0 && response["@odata.nextLink"] !== void 0) {
+      const remaining = await collectAllPages(
+        client,
+        response["@odata.nextLink"]
+      );
+      tasks.push(...remaining);
+    }
+    return formatResponse(tasks);
+  } catch (err) {
+    return formatError(parseGraphError(err));
+  }
+}
+async function handleGetTask(listId, taskId) {
+  try {
+    const token = await acquireToken();
+    const client = getGraphClient(token);
+    const task = await client.api(`/me/todo/lists/${listId}/tasks/${taskId}`).get();
+    return formatResponse(task);
+  } catch (err) {
+    return formatError(parseGraphError(err));
+  }
+}
+async function handleCreateTask(params) {
+  try {
+    const token = await acquireToken();
+    const client = getGraphClient(token);
+    const body = {
+      title: params.title
+    };
+    if (params.body !== void 0) {
+      body.body = { content: params.body, contentType: "text" };
+    }
+    if (params.dueDate !== void 0) {
+      body.dueDateTime = { dateTime: `${params.dueDate}T00:00:00`, timeZone: "UTC" };
+    }
+    if (params.importance !== void 0) {
+      body.importance = params.importance;
+    }
+    const created = await client.api(`/me/todo/lists/${params.listId}/tasks`).post(body);
+    return formatResponse(created);
+  } catch (err) {
+    return formatError(parseGraphError(err));
+  }
+}
+async function handleUpdateTask(params) {
+  try {
+    const token = await acquireToken();
+    const client = getGraphClient(token);
+    const patch = {};
+    if (params.title !== void 0) patch.title = params.title;
+    if (params.body !== void 0) patch.body = { content: params.body, contentType: "text" };
+    if (params.dueDate !== void 0) {
+      patch.dueDateTime = { dateTime: `${params.dueDate}T00:00:00`, timeZone: "UTC" };
+    }
+    if (params.importance !== void 0) patch.importance = params.importance;
+    const updated = await client.api(`/me/todo/lists/${params.listId}/tasks/${params.taskId}`).patch(patch);
+    return formatResponse(updated);
+  } catch (err) {
+    return formatError(parseGraphError(err));
+  }
+}
+async function handleCompleteTask(listId, taskId) {
+  try {
+    const token = await acquireToken();
+    const client = getGraphClient(token);
+    const updated = await client.api(`/me/todo/lists/${listId}/tasks/${taskId}`).patch({ status: "completed" });
+    return formatResponse(updated);
+  } catch (err) {
+    return formatError(parseGraphError(err));
+  }
+}
+async function handleDeleteTask(listId, taskId) {
+  try {
+    const token = await acquireToken();
+    const client = getGraphClient(token);
+    await client.api(`/me/todo/lists/${listId}/tasks/${taskId}`).delete();
+    return formatResponse({ deleted: true, taskId });
+  } catch (err) {
+    return formatError(parseGraphError(err));
+  }
+}
+
+// src/tools/tasks/index.ts
+function register(server) {
+  server.tool(
+    "list_task_lists",
+    "List all Microsoft To Do task lists for the signed-in user",
+    {},
+    async () => handleListTaskLists()
+  );
+  server.tool(
+    "list_tasks",
+    "List tasks in a specific To Do task list, with optional filter and limit",
+    ListTasksSchema,
+    async ({ listId, filter, top }) => handleListTasks(listId, filter, top)
+  );
+  server.tool(
+    "get_task",
+    "Get a single To Do task by list ID and task ID",
+    GetTaskSchema,
+    async ({ listId, taskId }) => handleGetTask(listId, taskId)
+  );
+  server.tool(
+    "create_task",
+    "Create a new task in a To Do task list",
+    CreateTaskSchema,
+    async (params) => handleCreateTask(params)
+  );
+  server.tool(
+    "update_task",
+    "Update an existing To Do task (title, body, due date, importance)",
+    UpdateTaskSchema,
+    async (params) => handleUpdateTask(params)
+  );
+  server.tool(
+    "complete_task",
+    "Mark a To Do task as completed",
+    CompleteTaskSchema,
+    async ({ listId, taskId }) => handleCompleteTask(listId, taskId)
+  );
+  server.tool(
+    "delete_task",
+    "Delete a To Do task permanently",
+    DeleteTaskSchema,
+    async ({ listId, taskId }) => handleDeleteTask(listId, taskId)
+  );
+}
+
+// src/tools/calendar/schemas.ts
+import { z as z2 } from "zod";
+var SearchEventsSchema = {
+  query: z2.string().optional().describe("Search query string for event subject/content"),
+  startDate: z2.string().optional().describe("Filter events starting on or after this date (ISO 8601, e.g. 2026-06-01)"),
+  endDate: z2.string().optional().describe("Filter events ending on or before this date (ISO 8601, e.g. 2026-06-30)"),
+  top: z2.number().int().min(1).max(100).optional().describe("Maximum number of events to return (1-100)")
+};
+var GetEventSchema = {
+  eventId: z2.string().describe("The ID of the calendar event")
+};
+var CreateEventSchema = {
+  subject: z2.string().describe("Event subject / title"),
+  start: z2.string().describe("Event start time in ISO 8601 format (e.g. 2026-06-01T10:00:00)"),
+  end: z2.string().describe("Event end time in ISO 8601 format (e.g. 2026-06-01T11:00:00)"),
+  timeZone: z2.string().optional().default("UTC").describe("IANA time zone for start/end (default: UTC)"),
+  attendees: z2.array(z2.string()).optional().describe("List of attendee email addresses"),
+  body: z2.string().optional().describe("Event body / description (HTML or plain text)"),
+  location: z2.string().optional().describe("Event location"),
+  isTeamsMeeting: z2.boolean().optional().describe("If true, create a Teams online meeting link")
+};
+var UpdateEventSchema = {
+  eventId: z2.string().describe("The ID of the calendar event to update"),
+  subject: z2.string().optional().describe("Updated event subject"),
+  start: z2.string().optional().describe("Updated start time in ISO 8601 format"),
+  end: z2.string().optional().describe("Updated end time in ISO 8601 format"),
+  timeZone: z2.string().optional().describe("IANA time zone for updated start/end"),
+  attendees: z2.array(z2.string()).optional().describe("Updated list of attendee email addresses"),
+  body: z2.string().optional().describe("Updated event body"),
+  location: z2.string().optional().describe("Updated event location")
+};
+var FindAvailabilitySchema = {
+  emails: z2.array(z2.string()).describe("List of email addresses to check availability for"),
+  startTime: z2.string().describe("Start of the availability window in ISO 8601 format"),
+  endTime: z2.string().describe("End of the availability window in ISO 8601 format"),
+  timeZone: z2.string().optional().default("UTC").describe("IANA time zone for the window (default: UTC)"),
+  intervalMinutes: z2.number().int().min(5).max(1440).optional().default(30).describe("Schedule slot interval in minutes (default: 30)")
+};
+
+// src/tools/calendar/handlers.ts
+async function handleSearchEvents(query, startDate, endDate, top) {
+  try {
+    const token = await acquireToken();
+    const client = getGraphClient(token);
+    let request = client.api("/me/events");
+    if (query !== void 0) {
+      request = request.search(`"${query}"`);
+    }
+    const filters = [];
+    if (startDate !== void 0) {
+      filters.push(`start/dateTime ge '${startDate}T00:00:00Z'`);
+    }
+    if (endDate !== void 0) {
+      filters.push(`end/dateTime le '${endDate}T23:59:59Z'`);
+    }
+    if (filters.length > 0) {
+      request = request.filter(filters.join(" and "));
+    }
+    if (top !== void 0) {
+      request = request.top(top);
+    }
+    request = request.select("id,subject,start,end,location,attendees,bodyPreview,isOnlineMeeting,onlineMeetingUrl");
+    const response = await request.get();
+    return formatResponse(response.value ?? []);
+  } catch (err) {
+    return formatError(parseGraphError(err));
+  }
+}
+async function handleGetEvent(eventId) {
+  try {
+    const token = await acquireToken();
+    const client = getGraphClient(token);
+    const event = await client.api(`/me/events/${eventId}`).get();
+    return formatResponse(event);
+  } catch (err) {
+    return formatError(parseGraphError(err));
+  }
+}
+async function handleCreateEvent(params) {
+  try {
+    const token = await acquireToken();
+    const client = getGraphClient(token);
+    const tz = params.timeZone ?? "UTC";
+    const eventBody = {
+      subject: params.subject,
+      start: { dateTime: params.start, timeZone: tz },
+      end: { dateTime: params.end, timeZone: tz }
+    };
+    if (params.body !== void 0) {
+      eventBody.body = { contentType: "text", content: params.body };
+    }
+    if (params.location !== void 0) {
+      eventBody.location = { displayName: params.location };
+    }
+    if (params.attendees !== void 0 && params.attendees.length > 0) {
+      eventBody.attendees = params.attendees.map((email) => ({
+        emailAddress: { address: email },
+        type: "required"
+      }));
+    }
+    if (params.isTeamsMeeting === true) {
+      eventBody.isOnlineMeeting = true;
+    }
+    const created = await client.api("/me/events").post(eventBody);
+    return formatResponse(created);
+  } catch (err) {
+    return formatError(parseGraphError(err));
+  }
+}
+async function handleUpdateEvent(params) {
+  try {
+    const token = await acquireToken();
+    const client = getGraphClient(token);
+    const patch = {};
+    const tz = params.timeZone ?? "UTC";
+    if (params.subject !== void 0) patch.subject = params.subject;
+    if (params.start !== void 0) patch.start = { dateTime: params.start, timeZone: tz };
+    if (params.end !== void 0) patch.end = { dateTime: params.end, timeZone: tz };
+    if (params.body !== void 0) patch.body = { contentType: "text", content: params.body };
+    if (params.location !== void 0) patch.location = { displayName: params.location };
+    if (params.attendees !== void 0) {
+      patch.attendees = params.attendees.map((email) => ({
+        emailAddress: { address: email },
+        type: "required"
+      }));
+    }
+    const updated = await client.api(`/me/events/${params.eventId}`).patch(patch);
+    return formatResponse(updated);
+  } catch (err) {
+    return formatError(parseGraphError(err));
+  }
+}
+async function handleFindAvailability(params) {
+  try {
+    const token = await acquireToken();
+    const client = getGraphClient(token);
+    const tz = params.timeZone ?? "UTC";
+    const interval = params.intervalMinutes ?? 30;
+    const requestBody = {
+      schedules: params.emails,
+      startTime: { dateTime: params.startTime, timeZone: tz },
+      endTime: { dateTime: params.endTime, timeZone: tz },
+      availabilityViewInterval: interval
+    };
+    const response = await client.api("/me/calendar/getSchedule").post(requestBody);
+    return formatResponse(response.value ?? []);
+  } catch (err) {
+    return formatError(parseGraphError(err));
+  }
+}
+
+// src/tools/calendar/index.ts
+function register2(server) {
+  server.tool(
+    "search_events",
+    "Search calendar events by query, date range, or both",
+    SearchEventsSchema,
+    async ({ query, startDate, endDate, top }) => handleSearchEvents(query, startDate, endDate, top)
+  );
+  server.tool(
+    "get_event",
+    "Get a single calendar event by ID",
+    GetEventSchema,
+    async ({ eventId }) => handleGetEvent(eventId)
+  );
+  server.tool(
+    "create_event",
+    "Create a new calendar event, optionally with attendees and a Teams meeting link",
+    CreateEventSchema,
+    async (params) => handleCreateEvent(params)
+  );
+  server.tool(
+    "update_event",
+    "Update an existing calendar event (subject, times, attendees, body, location)",
+    UpdateEventSchema,
+    async (params) => handleUpdateEvent(params)
+  );
+  server.tool(
+    "find_availability",
+    "Check free/busy availability for a list of people over a time window",
+    FindAvailabilitySchema,
+    async (params) => handleFindAvailability(params)
+  );
+}
+
+// src/tools/mail/schemas.ts
+import { z as z3 } from "zod";
+var SearchEmailsSchema = {
+  query: z3.string().optional().describe("Full-text search query across email subject and body"),
+  from: z3.string().optional().describe("Filter by sender email address"),
+  startDate: z3.string().optional().describe("Filter emails received on or after this date (ISO 8601)"),
+  endDate: z3.string().optional().describe("Filter emails received on or before this date (ISO 8601)"),
+  folder: z3.string().optional().describe('Mail folder name or well-known name (e.g. "inbox", "sentitems", "drafts")'),
+  top: z3.number().int().min(1).max(100).optional().describe("Maximum number of emails to return (1-100)")
+};
+var ReadEmailSchema = {
+  messageId: z3.string().describe("The ID of the email message")
+};
+var SendEmailSchema = {
+  to: z3.array(z3.string()).describe("List of recipient email addresses"),
+  subject: z3.string().describe("Email subject"),
+  body: z3.string().describe("Email body content"),
+  cc: z3.array(z3.string()).optional().describe("CC recipient email addresses"),
+  bcc: z3.array(z3.string()).optional().describe("BCC recipient email addresses"),
+  contentType: z3.enum(["text", "html"]).optional().default("text").describe("Body content type (default: text)")
+};
+var FlagEmailSchema = {
+  messageId: z3.string().describe("The ID of the email message"),
+  flagStatus: z3.enum(["flagged", "complete", "notFlagged"]).describe("Flag status to set on the message")
+};
+var MoveEmailSchema = {
+  messageId: z3.string().describe("The ID of the email message to move"),
+  destinationFolderId: z3.string().describe("ID or well-known folder name of the destination folder")
+};
+
+// src/tools/mail/handlers.ts
+async function handleSearchEmails(params) {
+  try {
+    const token = await acquireToken();
+    const client = getGraphClient(token);
+    const folderSegment = params.folder !== void 0 ? `/me/mailFolders/${params.folder}/messages` : "/me/messages";
+    let request = client.api(folderSegment);
+    if (params.query !== void 0) {
+      request = request.search(`"${params.query}"`);
+    }
+    const filters = [];
+    if (params.from !== void 0) {
+      filters.push(`from/emailAddress/address eq '${params.from}'`);
+    }
+    if (params.startDate !== void 0) {
+      filters.push(`receivedDateTime ge ${params.startDate}T00:00:00Z`);
+    }
+    if (params.endDate !== void 0) {
+      filters.push(`receivedDateTime le ${params.endDate}T23:59:59Z`);
+    }
+    if (filters.length > 0) {
+      request = request.filter(filters.join(" and "));
+    }
+    if (params.top !== void 0) {
+      request = request.top(params.top);
+    }
+    request = request.select("id,subject,from,receivedDateTime,bodyPreview,isRead,flag,hasAttachments");
+    const response = await request.get();
+    return formatResponse(response.value ?? []);
+  } catch (err) {
+    return formatError(parseGraphError(err));
+  }
+}
+async function handleReadEmail(messageId) {
+  try {
+    const token = await acquireToken();
+    const client = getGraphClient(token);
+    const message = await client.api(`/me/messages/${messageId}`).select("id,subject,from,toRecipients,ccRecipients,receivedDateTime,body,isRead,flag,hasAttachments").get();
+    return formatResponse(message);
+  } catch (err) {
+    return formatError(parseGraphError(err));
+  }
+}
+function toRecipients(emails) {
+  return emails.map((address) => ({ emailAddress: { address } }));
+}
+async function handleSendEmail(params) {
+  try {
+    const token = await acquireToken();
+    const client = getGraphClient(token);
+    const contentType = params.contentType ?? "text";
+    const message = {
+      message: {
+        subject: params.subject,
+        body: { contentType, content: params.body },
+        toRecipients: toRecipients(params.to),
+        ...params.cc !== void 0 && { ccRecipients: toRecipients(params.cc) },
+        ...params.bcc !== void 0 && { bccRecipients: toRecipients(params.bcc) }
+      }
+    };
+    await client.api("/me/sendMail").post(message);
+    return formatResponse({ sent: true, subject: params.subject });
+  } catch (err) {
+    return formatError(parseGraphError(err));
+  }
+}
+async function handleFlagEmail(messageId, flagStatus) {
+  try {
+    const token = await acquireToken();
+    const client = getGraphClient(token);
+    const updated = await client.api(`/me/messages/${messageId}`).patch({ flag: { flagStatus } });
+    return formatResponse(updated);
+  } catch (err) {
+    return formatError(parseGraphError(err));
+  }
+}
+async function handleListMailFolders() {
+  try {
+    const token = await acquireToken();
+    const client = getGraphClient(token);
+    const folders = await collectAllPages(client, "/me/mailFolders");
+    return formatResponse(folders);
+  } catch (err) {
+    return formatError(parseGraphError(err));
+  }
+}
+async function handleMoveEmail(messageId, destinationFolderId) {
+  try {
+    const token = await acquireToken();
+    const client = getGraphClient(token);
+    const moved = await client.api(`/me/messages/${messageId}/move`).post({ destinationId: destinationFolderId });
+    return formatResponse(moved);
+  } catch (err) {
+    return formatError(parseGraphError(err));
+  }
+}
+
+// src/tools/mail/index.ts
+function register3(server) {
+  server.tool(
+    "search_emails",
+    "Search emails by query, sender, date range, or folder",
+    SearchEmailsSchema,
+    async (params) => handleSearchEmails(params)
+  );
+  server.tool(
+    "read_email",
+    "Read the full content of an email message by ID",
+    ReadEmailSchema,
+    async ({ messageId }) => handleReadEmail(messageId)
+  );
+  server.tool(
+    "send_email",
+    "Send an email to one or more recipients",
+    SendEmailSchema,
+    async (params) => handleSendEmail(params)
+  );
+  server.tool(
+    "flag_email",
+    "Set the flag status on an email (flagged, complete, or notFlagged)",
+    FlagEmailSchema,
+    async ({ messageId, flagStatus }) => handleFlagEmail(messageId, flagStatus)
+  );
+  server.tool(
+    "list_mail_folders",
+    "List all mail folders for the signed-in user",
+    {},
+    async () => handleListMailFolders()
+  );
+  server.tool(
+    "move_email",
+    "Move an email to a different mail folder",
+    MoveEmailSchema,
+    async ({ messageId, destinationFolderId }) => handleMoveEmail(messageId, destinationFolderId)
+  );
+}
+
+// src/tools/contacts/schemas.ts
+import { z as z4 } from "zod";
+var EmailAddressSchema = z4.object({
+  address: z4.string().describe("Email address"),
+  name: z4.string().optional().describe("Display name for this email address")
+});
+var SearchContactsSchema = {
+  query: z4.string().describe("Search query (matches against name, email, company, etc.)"),
+  top: z4.number().int().min(1).max(100).optional().describe("Maximum number of contacts to return (1-100)")
+};
+var GetContactSchema = {
+  contactId: z4.string().describe("The ID of the contact")
+};
+var CreateContactSchema = {
+  givenName: z4.string().describe("Contact first name"),
+  surname: z4.string().optional().describe("Contact last name"),
+  emailAddresses: z4.array(EmailAddressSchema).optional().describe("Email addresses for the contact"),
+  businessPhones: z4.array(z4.string()).optional().describe("Business phone numbers"),
+  jobTitle: z4.string().optional().describe("Job title"),
+  companyName: z4.string().optional().describe("Company or organization name")
+};
+var UpdateContactSchema = {
+  contactId: z4.string().describe("The ID of the contact to update"),
+  givenName: z4.string().optional().describe("Updated first name"),
+  surname: z4.string().optional().describe("Updated last name"),
+  emailAddresses: z4.array(EmailAddressSchema).optional().describe("Updated email addresses"),
+  businessPhones: z4.array(z4.string()).optional().describe("Updated business phone numbers"),
+  jobTitle: z4.string().optional().describe("Updated job title"),
+  companyName: z4.string().optional().describe("Updated company name")
+};
+
+// src/tools/contacts/handlers.ts
+async function handleSearchContacts(query, top) {
+  try {
+    const token = await acquireToken();
+    const client = getGraphClient(token);
+    let request = client.api("/me/contacts").search(`"${query}"`).select("id,displayName,givenName,surname,emailAddresses,businessPhones,jobTitle,companyName");
+    if (top !== void 0) {
+      request = request.top(top);
+    }
+    const response = await request.get();
+    return formatResponse(response.value ?? []);
+  } catch (err) {
+    return formatError(parseGraphError(err));
+  }
+}
+async function handleGetContact(contactId) {
+  try {
+    const token = await acquireToken();
+    const client = getGraphClient(token);
+    const contact = await client.api(`/me/contacts/${contactId}`).get();
+    return formatResponse(contact);
+  } catch (err) {
+    return formatError(parseGraphError(err));
+  }
+}
+async function handleCreateContact(params) {
+  try {
+    const token = await acquireToken();
+    const client = getGraphClient(token);
+    const body = {
+      givenName: params.givenName
+    };
+    if (params.surname !== void 0) body.surname = params.surname;
+    if (params.emailAddresses !== void 0) body.emailAddresses = params.emailAddresses;
+    if (params.businessPhones !== void 0) body.businessPhones = params.businessPhones;
+    if (params.jobTitle !== void 0) body.jobTitle = params.jobTitle;
+    if (params.companyName !== void 0) body.companyName = params.companyName;
+    const created = await client.api("/me/contacts").post(body);
+    return formatResponse(created);
+  } catch (err) {
+    return formatError(parseGraphError(err));
+  }
+}
+async function handleUpdateContact(params) {
+  try {
+    const token = await acquireToken();
+    const client = getGraphClient(token);
+    const patch = {};
+    if (params.givenName !== void 0) patch.givenName = params.givenName;
+    if (params.surname !== void 0) patch.surname = params.surname;
+    if (params.emailAddresses !== void 0) patch.emailAddresses = params.emailAddresses;
+    if (params.businessPhones !== void 0) patch.businessPhones = params.businessPhones;
+    if (params.jobTitle !== void 0) patch.jobTitle = params.jobTitle;
+    if (params.companyName !== void 0) patch.companyName = params.companyName;
+    const updated = await client.api(`/me/contacts/${params.contactId}`).patch(patch);
+    return formatResponse(updated);
+  } catch (err) {
+    return formatError(parseGraphError(err));
+  }
+}
+
+// src/tools/contacts/index.ts
+function register4(server) {
+  server.tool(
+    "search_contacts",
+    "Search contacts by name, email, company, or other fields",
+    SearchContactsSchema,
+    async ({ query, top }) => handleSearchContacts(query, top)
+  );
+  server.tool(
+    "get_contact",
+    "Get a single contact by ID",
+    GetContactSchema,
+    async ({ contactId }) => handleGetContact(contactId)
+  );
+  server.tool(
+    "create_contact",
+    "Create a new contact in the signed-in user's contacts",
+    CreateContactSchema,
+    async (params) => handleCreateContact(params)
+  );
+  server.tool(
+    "update_contact",
+    "Update an existing contact (name, email, phone, title, company)",
+    UpdateContactSchema,
+    async (params) => handleUpdateContact(params)
+  );
+}
+
+// src/version.ts
+var VERSION = true ? "0.1.0" : "0.0.0-dev";
+
+// src/server.ts
+function createServer() {
+  const server = new McpServer({
+    name: "m365-mcp",
+    version: VERSION
+  });
+  register(server);
+  register2(server);
+  register3(server);
+  register4(server);
+  return server;
+}
+
+// src/index.ts
+var command = process.argv[2];
+async function main() {
+  if (command === "setup") {
+    const { runSetupCommand } = await import("./setup-K6EYBEFH.js");
+    await runSetupCommand();
+    return;
+  }
+  if (command === "auth") {
+    await runAuthCommand();
+    return;
+  }
+  const server = createServer();
+  const transport = new StdioServerTransport();
+  process.on("uncaughtException", (err) => {
+    process.stderr.write(`[m365-mcp] Uncaught exception: ${String(err)}
+`);
+  });
+  process.on("unhandledRejection", (reason) => {
+    process.stderr.write(`[m365-mcp] Unhandled rejection: ${String(reason)}
+`);
+  });
+  await server.connect(transport);
+}
+main().catch((err) => {
+  process.stderr.write(`[m365-mcp] Fatal startup error: ${String(err)}
+`);
+  process.exit(1);
+});
+//# sourceMappingURL=index.js.map