@joshluedeman/m365-mcp 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1183 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// node_modules/tsup/assets/cjs_shims.js
+var init_cjs_shims = __esm({
+  "node_modules/tsup/assets/cjs_shims.js"() {
+    "use strict";
+  }
+});
+
+// src/auth/token-cache.ts
+function ensureCacheDir() {
+  if (!import_fs.default.existsSync(CACHE_DIR)) {
+    import_fs.default.mkdirSync(CACHE_DIR, { recursive: true });
+  }
+}
+var import_fs, import_path, import_os, CACHE_DIR, CACHE_PATH, tokenCachePlugin;
+var init_token_cache = __esm({
+  "src/auth/token-cache.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_fs = __toESM(require("fs"), 1);
+    import_path = __toESM(require("path"), 1);
+    import_os = __toESM(require("os"), 1);
+    CACHE_DIR = import_path.default.join(import_os.default.homedir(), ".config", "m365-mcp");
+    CACHE_PATH = import_path.default.join(CACHE_DIR, "token-cache.json");
+    tokenCachePlugin = {
+      async beforeCacheAccess(tokenCacheContext) {
+        try {
+          if (import_fs.default.existsSync(CACHE_PATH)) {
+            const data = import_fs.default.readFileSync(CACHE_PATH, "utf-8");
+            tokenCacheContext.tokenCache.deserialize(data);
+          }
+        } catch (err) {
+          process.stderr.write(`[m365-mcp] token cache read error (starting fresh): ${String(err)}
+`);
+        }
+      },
+      async afterCacheAccess(tokenCacheContext) {
+        if (!tokenCacheContext.cacheHasChanged) {
+          return;
+        }
+        try {
+          ensureCacheDir();
+          const data = tokenCacheContext.tokenCache.serialize();
+          import_fs.default.writeFileSync(CACHE_PATH, data, { encoding: "utf-8", mode: 384 });
+          import_fs.default.chmodSync(CACHE_PATH, 384);
+        } catch (err) {
+          process.stderr.write(`[m365-mcp] token cache write error: ${String(err)}
+`);
+        }
+      }
+    };
+  }
+});
+
+// src/auth/app-config.ts
+var DEFAULT_CLIENT_ID;
+var init_app_config = __esm({
+  "src/auth/app-config.ts"() {
+    "use strict";
+    init_cjs_shims();
+    DEFAULT_CLIENT_ID = "dc9f42bd-30a5-4c43-a498-305ef0c3ad87";
+  }
+});
+
+// src/auth/msal-client.ts
+function readConfigFile(filePath) {
+  try {
+    if (import_fs2.default.existsSync(filePath)) {
+      const raw = import_fs2.default.readFileSync(filePath, "utf-8");
+      return JSON.parse(raw);
+    }
+  } catch {
+  }
+  return null;
+}
+function loadClientId() {
+  const envClientId = process.env["M365_MCP_CLIENT_ID"];
+  if (envClientId) {
+    return envClientId;
+  }
+  const userConfig = readConfigFile(USER_CONFIG_PATH);
+  if (userConfig?.clientId) {
+    return userConfig.clientId;
+  }
+  const localConfig = readConfigFile(LOCAL_CONFIG_PATH);
+  if (localConfig?.clientId) {
+    return localConfig.clientId;
+  }
+  if (DEFAULT_CLIENT_ID) {
+    return DEFAULT_CLIENT_ID;
+  }
+  throw new Error('No client ID configured. Run "npx m365-mcp setup" to get started.');
+}
+function loadTenantId() {
+  const envTenantId = process.env["M365_MCP_TENANT_ID"];
+  if (envTenantId) {
+    return envTenantId;
+  }
+  const userConfig = readConfigFile(USER_CONFIG_PATH);
+  if (userConfig?.tenantId) {
+    return userConfig.tenantId;
+  }
+  const localConfig = readConfigFile(LOCAL_CONFIG_PATH);
+  if (localConfig?.tenantId) {
+    return localConfig.tenantId;
+  }
+  return "common";
+}
+function getMsalClient() {
+  if (_msalClient) {
+    return _msalClient;
+  }
+  const clientId = loadClientId();
+  const tenantId = loadTenantId();
+  const msalConfig = {
+    auth: {
+      clientId,
+      authority: `https://login.microsoftonline.com/${tenantId}`
+    },
+    cache: {
+      cachePlugin: tokenCachePlugin
+    },
+    system: {
+      loggerOptions: {
+        loggerCallback: (_level, message, containsPii) => {
+          if (!containsPii) {
+            process.stderr.write(`[msal] ${message}
+`);
+          }
+        },
+        piiLoggingEnabled: false
+      }
+    }
+  };
+  _msalClient = new import_msal_node.PublicClientApplication(msalConfig);
+  return _msalClient;
+}
+var import_fs2, import_path2, import_os2, import_msal_node, USER_CONFIG_PATH, LOCAL_CONFIG_PATH, _msalClient;
+var init_msal_client = __esm({
+  "src/auth/msal-client.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_fs2 = __toESM(require("fs"), 1);
+    import_path2 = __toESM(require("path"), 1);
+    import_os2 = __toESM(require("os"), 1);
+    import_msal_node = require("@azure/msal-node");
+    init_token_cache();
+    init_app_config();
+    USER_CONFIG_PATH = import_path2.default.join(import_os2.default.homedir(), ".config", "m365-mcp", "config.json");
+    LOCAL_CONFIG_PATH = import_path2.default.join(process.cwd(), ".m365-mcp.json");
+  }
+});
+
+// src/auth/scopes.ts
+var GRAPH_SCOPES;
+var init_scopes = __esm({
+  "src/auth/scopes.ts"() {
+    "use strict";
+    init_cjs_shims();
+    GRAPH_SCOPES = [
+      "Mail.ReadWrite",
+      "Mail.Send",
+      "Calendars.ReadWrite",
+      "Tasks.ReadWrite",
+      "Contacts.ReadWrite",
+      "offline_access",
+      "User.Read"
+    ];
+  }
+});
+
+// src/auth/device-code-flow.ts
+async function trySilentAcquire() {
+  const client = getMsalClient();
+  const accounts = await client.getAllAccounts();
+  if (accounts.length === 0) {
+    return null;
+  }
+  for (const account of accounts) {
+    try {
+      const result = await client.acquireTokenSilent({
+        account,
+        scopes: GRAPH_SCOPES
+      });
+      if (result?.accessToken) {
+        return result.accessToken;
+      }
+    } catch {
+    }
+  }
+  return null;
+}
+async function acquireToken() {
+  const silentToken = await trySilentAcquire();
+  if (silentToken) {
+    return silentToken;
+  }
+  const client = getMsalClient();
+  const deviceCodeRequest = {
+    scopes: GRAPH_SCOPES,
+    deviceCodeCallback: (response) => {
+      process.stderr.write("\n[m365-mcp] Authentication required\n");
+      process.stderr.write(`[m365-mcp] ${response.message}
+
+`);
+    }
+  };
+  const result = await client.acquireTokenByDeviceCode(deviceCodeRequest);
+  if (!result?.accessToken) {
+    throw new Error("Device code authentication did not return an access token.");
+  }
+  return result.accessToken;
+}
+async function runAuthCommand() {
+  process.stderr.write("[m365-mcp] Starting authentication...\n");
+  try {
+    const token = await acquireToken();
+    if (!token) {
+      process.stderr.write("[m365-mcp] Authentication failed \u2014 no token returned.\n");
+      process.exit(1);
+    }
+    const client = getMsalClient();
+    const accounts = await client.getAllAccounts();
+    const account = accounts[0];
+    if (account) {
+      process.stderr.write(`[m365-mcp] Authenticated as: ${account.username}
+`);
+    } else {
+      process.stderr.write("[m365-mcp] Authentication successful.\n");
+    }
+  } catch (err) {
+    process.stderr.write(`[m365-mcp] Authentication error: ${String(err)}
+`);
+    process.exit(1);
+  }
+}
+var init_device_code_flow = __esm({
+  "src/auth/device-code-flow.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_msal_client();
+    init_scopes();
+  }
+});
+
+// src/setup/prompts.ts
+function createRl() {
+  let input;
+  try {
+    input = (0, import_fs3.createReadStream)("/dev/tty");
+  } catch {
+    input = process.stdin;
+  }
+  return (0, import_readline.createInterface)({
+    input,
+    output: process.stderr,
+    terminal: true
+  });
+}
+async function question(prompt) {
+  const rl = createRl();
+  return new Promise((resolve) => {
+    rl.question(prompt, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+async function confirm(prompt, defaultYes = false) {
+  const hint = defaultYes ? "[Y/n]" : "[y/N]";
+  const answer = await question(`${prompt} ${hint}: `);
+  if (answer === "") {
+    return defaultYes;
+  }
+  return answer.toLowerCase().startsWith("y");
+}
+var import_readline, import_fs3;
+var init_prompts = __esm({
+  "src/setup/prompts.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_readline = require("readline");
+    import_fs3 = require("fs");
+  }
+});
+
+// src/setup/index.ts
+var setup_exports = {};
+__export(setup_exports, {
+  runSetupCommand: () => runSetupCommand
+});
+function stderr(msg) {
+  process.stderr.write(msg + "\n");
+}
+async function runSetupCommand() {
+  stderr("m365-mcp \u2014 Microsoft 365 for Claude");
+  stderr("");
+  stderr("This will grant access to:");
+  stderr("  \u2022 Mail (read, send)");
+  stderr("  \u2022 Calendar (read, create, update)");
+  stderr("  \u2022 Tasks (read, create, update, delete)");
+  stderr("  \u2022 Contacts (read, create, update)");
+  stderr("");
+  const cacheExists = import_fs4.default.existsSync(TOKEN_CACHE_PATH);
+  if (cacheExists) {
+    const reauth = await confirm("You're already signed in. Re-authenticate?", false);
+    if (!reauth) {
+      stderr("Setup cancelled.");
+      return;
+    }
+  }
+  await runAuthCommand();
+  stderr("Setup complete! Add m365-mcp to your Claude Desktop or Claude Code config to get started.");
+}
+var import_fs4, import_path3, import_os3, TOKEN_CACHE_PATH;
+var init_setup = __esm({
+  "src/setup/index.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_fs4 = __toESM(require("fs"), 1);
+    import_path3 = __toESM(require("path"), 1);
+    import_os3 = __toESM(require("os"), 1);
+    init_device_code_flow();
+    init_prompts();
+    TOKEN_CACHE_PATH = import_path3.default.join(import_os3.default.homedir(), ".config", "m365-mcp", "token-cache.json");
+  }
+});
+
+// src/index.ts
+init_cjs_shims();
+var import_stdio = require("@modelcontextprotocol/sdk/server/stdio.js");
+init_device_code_flow();
+
+// src/server.ts
+init_cjs_shims();
+var import_mcp = require("@modelcontextprotocol/sdk/server/mcp.js");
+
+// src/tools/tasks/index.ts
+init_cjs_shims();
+
+// src/tools/tasks/schemas.ts
+init_cjs_shims();
+var import_zod = require("zod");
+var ListTasksSchema = {
+  listId: import_zod.z.string().describe("The ID of the To Do task list"),
+  filter: import_zod.z.string().optional().describe(`OData $filter expression (e.g. "status eq 'notStarted'")`),
+  top: import_zod.z.number().int().min(1).max(100).optional().describe("Maximum number of tasks to return (1-100)")
+};
+var GetTaskSchema = {
+  listId: import_zod.z.string().describe("The ID of the To Do task list"),
+  taskId: import_zod.z.string().describe("The ID of the task")
+};
+var CreateTaskSchema = {
+  listId: import_zod.z.string().describe("The ID of the To Do task list"),
+  title: import_zod.z.string().describe("Task title"),
+  body: import_zod.z.string().optional().describe("Task body / notes (plain text)"),
+  dueDate: import_zod.z.string().optional().describe("Due date in ISO 8601 format (e.g. 2026-06-01)"),
+  importance: import_zod.z.enum(["low", "normal", "high"]).optional().describe("Task importance level")
+};
+var UpdateTaskSchema = {
+  listId: import_zod.z.string().describe("The ID of the To Do task list"),
+  taskId: import_zod.z.string().describe("The ID of the task"),
+  title: import_zod.z.string().optional().describe("Updated task title"),
+  body: import_zod.z.string().optional().describe("Updated task body / notes"),
+  dueDate: import_zod.z.string().optional().describe("Updated due date in ISO 8601 format"),
+  importance: import_zod.z.enum(["low", "normal", "high"]).optional().describe("Updated importance level")
+};
+var CompleteTaskSchema = {
+  listId: import_zod.z.string().describe("The ID of the To Do task list"),
+  taskId: import_zod.z.string().describe("The ID of the task to mark complete")
+};
+var DeleteTaskSchema = {
+  listId: import_zod.z.string().describe("The ID of the To Do task list"),
+  taskId: import_zod.z.string().describe("The ID of the task to delete")
+};
+
+// src/tools/tasks/handlers.ts
+init_cjs_shims();
+init_device_code_flow();
+
+// src/graph/client.ts
+init_cjs_shims();
+var import_microsoft_graph_client = require("@microsoft/microsoft-graph-client");
+function getGraphClient(accessToken) {
+  const authProvider = {
+    getAccessToken: async () => accessToken
+  };
+  return import_microsoft_graph_client.Client.initWithMiddleware({ authProvider });
+}
+
+// src/utils/pagination.ts
+init_cjs_shims();
+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
+init_cjs_shims();
+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
+init_cjs_shims();
+var import_types = require("@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/index.ts
+init_cjs_shims();
+
+// src/tools/calendar/schemas.ts
+init_cjs_shims();
+var import_zod2 = require("zod");
+var SearchEventsSchema = {
+  query: import_zod2.z.string().optional().describe("Search query string for event subject/content"),
+  startDate: import_zod2.z.string().optional().describe("Filter events starting on or after this date (ISO 8601, e.g. 2026-06-01)"),
+  endDate: import_zod2.z.string().optional().describe("Filter events ending on or before this date (ISO 8601, e.g. 2026-06-30)"),
+  top: import_zod2.z.number().int().min(1).max(100).optional().describe("Maximum number of events to return (1-100)")
+};
+var GetEventSchema = {
+  eventId: import_zod2.z.string().describe("The ID of the calendar event")
+};
+var CreateEventSchema = {
+  subject: import_zod2.z.string().describe("Event subject / title"),
+  start: import_zod2.z.string().describe("Event start time in ISO 8601 format (e.g. 2026-06-01T10:00:00)"),
+  end: import_zod2.z.string().describe("Event end time in ISO 8601 format (e.g. 2026-06-01T11:00:00)"),
+  timeZone: import_zod2.z.string().optional().default("UTC").describe("IANA time zone for start/end (default: UTC)"),
+  attendees: import_zod2.z.array(import_zod2.z.string()).optional().describe("List of attendee email addresses"),
+  body: import_zod2.z.string().optional().describe("Event body / description (HTML or plain text)"),
+  location: import_zod2.z.string().optional().describe("Event location"),
+  isTeamsMeeting: import_zod2.z.boolean().optional().describe("If true, create a Teams online meeting link")
+};
+var UpdateEventSchema = {
+  eventId: import_zod2.z.string().describe("The ID of the calendar event to update"),
+  subject: import_zod2.z.string().optional().describe("Updated event subject"),
+  start: import_zod2.z.string().optional().describe("Updated start time in ISO 8601 format"),
+  end: import_zod2.z.string().optional().describe("Updated end time in ISO 8601 format"),
+  timeZone: import_zod2.z.string().optional().describe("IANA time zone for updated start/end"),
+  attendees: import_zod2.z.array(import_zod2.z.string()).optional().describe("Updated list of attendee email addresses"),
+  body: import_zod2.z.string().optional().describe("Updated event body"),
+  location: import_zod2.z.string().optional().describe("Updated event location")
+};
+var FindAvailabilitySchema = {
+  emails: import_zod2.z.array(import_zod2.z.string()).describe("List of email addresses to check availability for"),
+  startTime: import_zod2.z.string().describe("Start of the availability window in ISO 8601 format"),
+  endTime: import_zod2.z.string().describe("End of the availability window in ISO 8601 format"),
+  timeZone: import_zod2.z.string().optional().default("UTC").describe("IANA time zone for the window (default: UTC)"),
+  intervalMinutes: import_zod2.z.number().int().min(5).max(1440).optional().default(30).describe("Schedule slot interval in minutes (default: 30)")
+};
+
+// src/tools/calendar/handlers.ts
+init_cjs_shims();
+init_device_code_flow();
+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/index.ts
+init_cjs_shims();
+
+// src/tools/mail/schemas.ts
+init_cjs_shims();
+var import_zod3 = require("zod");
+var SearchEmailsSchema = {
+  query: import_zod3.z.string().optional().describe("Full-text search query across email subject and body"),
+  from: import_zod3.z.string().optional().describe("Filter by sender email address"),
+  startDate: import_zod3.z.string().optional().describe("Filter emails received on or after this date (ISO 8601)"),
+  endDate: import_zod3.z.string().optional().describe("Filter emails received on or before this date (ISO 8601)"),
+  folder: import_zod3.z.string().optional().describe('Mail folder name or well-known name (e.g. "inbox", "sentitems", "drafts")'),
+  top: import_zod3.z.number().int().min(1).max(100).optional().describe("Maximum number of emails to return (1-100)")
+};
+var ReadEmailSchema = {
+  messageId: import_zod3.z.string().describe("The ID of the email message")
+};
+var SendEmailSchema = {
+  to: import_zod3.z.array(import_zod3.z.string()).describe("List of recipient email addresses"),
+  subject: import_zod3.z.string().describe("Email subject"),
+  body: import_zod3.z.string().describe("Email body content"),
+  cc: import_zod3.z.array(import_zod3.z.string()).optional().describe("CC recipient email addresses"),
+  bcc: import_zod3.z.array(import_zod3.z.string()).optional().describe("BCC recipient email addresses"),
+  contentType: import_zod3.z.enum(["text", "html"]).optional().default("text").describe("Body content type (default: text)")
+};
+var FlagEmailSchema = {
+  messageId: import_zod3.z.string().describe("The ID of the email message"),
+  flagStatus: import_zod3.z.enum(["flagged", "complete", "notFlagged"]).describe("Flag status to set on the message")
+};
+var MoveEmailSchema = {
+  messageId: import_zod3.z.string().describe("The ID of the email message to move"),
+  destinationFolderId: import_zod3.z.string().describe("ID or well-known folder name of the destination folder")
+};
+
+// src/tools/mail/handlers.ts
+init_cjs_shims();
+init_device_code_flow();
+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/index.ts
+init_cjs_shims();
+
+// src/tools/contacts/schemas.ts
+init_cjs_shims();
+var import_zod4 = require("zod");
+var EmailAddressSchema = import_zod4.z.object({
+  address: import_zod4.z.string().describe("Email address"),
+  name: import_zod4.z.string().optional().describe("Display name for this email address")
+});
+var SearchContactsSchema = {
+  query: import_zod4.z.string().describe("Search query (matches against name, email, company, etc.)"),
+  top: import_zod4.z.number().int().min(1).max(100).optional().describe("Maximum number of contacts to return (1-100)")
+};
+var GetContactSchema = {
+  contactId: import_zod4.z.string().describe("The ID of the contact")
+};
+var CreateContactSchema = {
+  givenName: import_zod4.z.string().describe("Contact first name"),
+  surname: import_zod4.z.string().optional().describe("Contact last name"),
+  emailAddresses: import_zod4.z.array(EmailAddressSchema).optional().describe("Email addresses for the contact"),
+  businessPhones: import_zod4.z.array(import_zod4.z.string()).optional().describe("Business phone numbers"),
+  jobTitle: import_zod4.z.string().optional().describe("Job title"),
+  companyName: import_zod4.z.string().optional().describe("Company or organization name")
+};
+var UpdateContactSchema = {
+  contactId: import_zod4.z.string().describe("The ID of the contact to update"),
+  givenName: import_zod4.z.string().optional().describe("Updated first name"),
+  surname: import_zod4.z.string().optional().describe("Updated last name"),
+  emailAddresses: import_zod4.z.array(EmailAddressSchema).optional().describe("Updated email addresses"),
+  businessPhones: import_zod4.z.array(import_zod4.z.string()).optional().describe("Updated business phone numbers"),
+  jobTitle: import_zod4.z.string().optional().describe("Updated job title"),
+  companyName: import_zod4.z.string().optional().describe("Updated company name")
+};
+
+// src/tools/contacts/handlers.ts
+init_cjs_shims();
+init_device_code_flow();
+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
+init_cjs_shims();
+var VERSION = true ? "0.1.0" : "0.0.0-dev";
+
+// src/server.ts
+function createServer() {
+  const server = new import_mcp.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: runSetupCommand2 } = await Promise.resolve().then(() => (init_setup(), setup_exports));
+    await runSetupCommand2();
+    return;
+  }
+  if (command === "auth") {
+    await runAuthCommand();
+    return;
+  }
+  const server = createServer();
+  const transport = new import_stdio.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.cjs.map