@softeria/ms-365-mcp-server 0.157.1 → 0.158.0

package/dist/graph-tools.js

@@ -1,58 +1,66 @@
 import { CallToolRequestSchema } from "@modelcontextprotocol/sdk/types.js";
 import { randomUUID } from "crypto";
-import logger from "./logger.js";
+import { readFileSync } from "fs";
+import { access } from "fs/promises";
+import path from "path";
+import { fileURLToPath } from "url";
+import { z } from "zod";
 import { auditLog, getUserIdentityForAudit } from "./audit-log.js";
-import { isDestructiveOperation } from "./lib/destructive-ops.js";
-import { describePathParam } from "./lib/path-params.js";
-import { getAttachmentMinting } from "./lib/attachment-minting.js";
-import {
-  buildAttachmentUrl,
-  isPlainGraphPath,
-  TicketStoreFullError
-} from "./lib/attachment-tickets.js";
-import {
-  anyFieldPresent,
-  isTransportEnvelope,
-  parseSelectFields,
-  projectSelectedFields
-} from "./lib/select-projection.js";
+import { deriveTargetResource } from "./audit-target-resource.js";
 import {
   getEndpointScopeGroups,
   getMissingAllowedScopesForGroups,
   parseAllowedScopes
 } from "./auth.js";
-import { api } from "./generated/client.js";
 import { api as betaApi } from "./generated/client-beta.js";
-const allEndpoints = [...api.endpoints, ...betaApi.endpoints];
-import { z } from "zod";
-import { readFileSync } from "fs";
-import { access } from "fs/promises";
-import path from "path";
-import { fileURLToPath } from "url";
-import { TOOL_CATEGORIES } from "./tool-categories.js";
-import { getRequestTokens } from "./request-context.js";
-import { parseTeamsUrl } from "./lib/teams-url-parser.js";
+import { api } from "./generated/client.js";
+import { getAttachmentMinting } from "./lib/attachment-minting.js";
+import {
+  buildAttachmentUrl,
+  isPlainGraphPath,
+  TicketStoreFullError
+} from "./lib/attachment-tickets.js";
 import { buildBM25Index, scoreQuery, tokenize } from "./lib/bm25.js";
-import { deriveTargetResource } from "./audit-target-resource.js";
-import { describeToolSchema, describeUtilityToolSchema } from "./lib/tool-schema.js";
-import { queryParameterSchema } from "./lib/query-parameter-schema.js";
+import { isDestructiveOperation } from "./lib/destructive-ops.js";
 import {
-  TOP_UNSUPPORTED_DELTA_TOOLS,
-  shouldOmitTopParam,
-  paginationAllowed,
-  positiveIntFromEnv,
-  DEFAULT_MAX_PAGES,
-  getMaxPages,
-  isFetchAllPagesApplicable,
   CONFIRM_PARAM_DESCRIPTION,
-  TIMEZONE_PARAM_DESCRIPTION,
+  DEFAULT_MAX_PAGES,
   EXPAND_EXTENDED_PROPERTIES_PARAM_DESCRIPTION,
   getAcceptParamDescription,
   getAccountParamDescription,
   getFetchAllPagesParamDescription,
+  getMaxPages,
+  isFetchAllPagesApplicable,
+  isSkiptokenApplicable,
+  paginationAllowed,
+  positiveIntFromEnv,
+  shouldOmitTopParam,
   SKIPTOKEN_PARAM_DESCRIPTION,
-  isSkiptokenApplicable
+  TIMEZONE_PARAM_DESCRIPTION,
+  TOP_UNSUPPORTED_DELTA_TOOLS
 } from "./lib/param-descriptions.js";
+import { describePathParam } from "./lib/path-params.js";
+import { queryParameterSchema } from "./lib/query-parameter-schema.js";
+import {
+  anyFieldPresent,
+  isTransportEnvelope,
+  parseSelectFields,
+  projectSelectedFields
+} from "./lib/select-projection.js";
+import { parseTeamsUrl } from "./lib/teams-url-parser.js";
+import { describeToolSchema, describeUtilityToolSchema } from "./lib/tool-schema.js";
+import {
+  restrictUserFieldQuery,
+  restrictUserFieldUrl,
+  shouldStripUserFieldExpand,
+  stripUserFieldExpandFromUrl,
+  targetsUserProfile,
+  userFieldEnforcement
+} from "./lib/user-field-policy.js";
+import logger from "./logger.js";
+import { getRequestTokens } from "./request-context.js";
+import { TOOL_CATEGORIES } from "./tool-categories.js";
+const allEndpoints = [...api.endpoints, ...betaApi.endpoints];
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 const endpointsData = JSON.parse(
@@ -81,6 +89,16 @@ function clampTopQueryParam(queryParams) {
   logger.info(`Clamping $top from ${requested} to ${cap} (MS365_MCP_MAX_TOP)`);
   queryParams["$top"] = String(cap);
 }
+function parseUserFields(value) {
+  if (value === void 0) return void 0;
+  const fields = value.split(",").map((field) => field.trim()).filter(Boolean);
+  if (fields.length === 0) {
+    throw new Error(
+      "User field allowlist was configured but names no fields. Provide one or more comma-separated Graph fields, or omit --user-fields / MS365_MCP_USER_FIELDS."
+    );
+  }
+  return fields;
+}
 const OUTLOOK_MAIL_PATH = /^\/(?:me|users\/[^/]+)(?:\/(?:mailFolders|childFolders)\/[^/]+)*\/messages(?:\/delta\(\))?$/i;
 function isOutlookMailPath(path2) {
   return OUTLOOK_MAIL_PATH.test(path2);
@@ -640,7 +658,7 @@ const UTILITY_TOOLS = [
       }
       return schema;
     },
-    execute: async (params, { graphClient, authManager }) => {
+    execute: async (params, { graphClient, authManager, userFields }) => {
       const target = params.target;
       const accountParam = params.account;
       if (typeof target !== "string" || target.length === 0) {
@@ -667,6 +685,8 @@ const UTILITY_TOOLS = [
           isError: true
         };
       }
+      const restrictedTarget = userProfilePassthroughError(target, userFields);
+      if (restrictedTarget) return restrictedTarget;
       try {
         const accountModeError = await checkAccountParamInBearerMode(accountParam, authManager);
         if (accountModeError) {
@@ -721,7 +741,7 @@ const UTILITY_TOOLS = [
       }
       return schema;
     },
-    execute: async (params, { graphClient, authManager }) => {
+    execute: async (params, { graphClient, authManager, userFields }) => {
       const target = params.target;
       const outputPath = params.outputPath;
       const accountParam = params.account;
@@ -762,6 +782,8 @@ const UTILITY_TOOLS = [
           isError: true
         };
       }
+      const restrictedTarget = userProfilePassthroughError(target, userFields);
+      if (restrictedTarget) return restrictedTarget;
       if (!path.isAbsolute(outputPath)) {
         return {
           content: [
@@ -858,7 +880,7 @@ const UTILITY_TOOLS = [
       }
       return schema;
     },
-    execute: async (params, { graphClient, authManager }) => {
+    execute: async (params, { graphClient, authManager, userFields }) => {
       const target = params.target;
       const accountParam = params.account;
       if (typeof target !== "string" || target.length === 0) {
@@ -885,6 +907,8 @@ const UTILITY_TOOLS = [
           isError: true
         };
       }
+      const restrictedTarget = userProfilePassthroughError(target, userFields);
+      if (restrictedTarget) return restrictedTarget;
       const queryIdx = target.indexOf("?");
       if (queryIdx >= 0) {
         return {
@@ -1096,6 +1120,69 @@ const READ_ONLY_BODY_FIELDS = /* @__PURE__ */ new Set([
 function isPlainObject(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
+function restrictBatchSubrequests(body, allowlist) {
+  const restricted = /* @__PURE__ */ new Map();
+  let changed = false;
+  let parsed = body;
+  const wasString = typeof body === "string";
+  if (wasString) {
+    try {
+      parsed = JSON.parse(body);
+    } catch {
+      return { body, restricted };
+    }
+  }
+  if (!isPlainObject(parsed) || !Array.isArray(parsed.requests)) return { body, restricted };
+  parsed.requests.forEach((request, index) => {
+    if (!isPlainObject(request) || typeof request.url !== "string") return;
+    const method = typeof request.method === "string" ? request.method.toUpperCase() : "GET";
+    const enforcement = userFieldEnforcement(request.url);
+    if (method !== "GET") return;
+    if (enforcement !== "none") {
+      const { url, fields } = restrictUserFieldUrl(request.url, allowlist, enforcement);
+      request.url = url;
+      restricted.set(String(request.id ?? index), fields);
+      changed = true;
+      logger.info(`Restricting batch subrequest ${String(request.id ?? index)} to: ${fields}`);
+    } else if (shouldStripUserFieldExpand(request.url)) {
+      const url = stripUserFieldExpandFromUrl(request.url);
+      if (url !== request.url) {
+        request.url = url;
+        changed = true;
+        logger.info(`Removing $expand from batch subrequest ${String(request.id ?? index)}`);
+      }
+    }
+  });
+  if (!changed) return { body, restricted };
+  return { body: wasString ? JSON.stringify(parsed) : parsed, restricted };
+}
+function projectBatchSubresponses(data, restricted) {
+  if (!isPlainObject(data) || !Array.isArray(data.responses)) return data;
+  return {
+    ...data,
+    responses: data.responses.map((subresponse) => {
+      if (!isPlainObject(subresponse)) return subresponse;
+      const fields = restricted.get(String(subresponse.id));
+      if (!fields) return subresponse;
+      return { ...subresponse, body: projectSelectedFields(subresponse.body, fields, true) };
+    })
+  };
+}
+function userProfilePassthroughError(target, userFields) {
+  if (userFields === void 0 || !targetsUserProfile(target)) return void 0;
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify({
+          error: "user_fields_restricted",
+          message: "This deployment restricts which user profile fields may be returned, and this tool returns the response bytes verbatim. Use list-users, which applies the restriction."
+        })
+      }
+    ],
+    isError: true
+  };
+}
 function hasOwn(obj, key) {
   return Object.prototype.hasOwnProperty.call(obj, key);
 }
@@ -1106,7 +1193,7 @@ function describeParamsForLog(params) {
     return `[unserializable: ${error instanceof Error ? error.name : "unknown error"}]`;
   }
 }
-async function executeGraphTool(tool, config, graphClient, params, authManager) {
+async function executeGraphTool(tool, config, graphClient, params, authManager, userFields) {
   logger.info(`Tool ${tool.alias} called with params: ${describeParamsForLog(params)}`);
   if (isConfirmGateEnabled() && isDestructiveOperation(tool.method, config) && params.confirm !== true) {
     logger.warn(
@@ -1364,8 +1451,26 @@ async function executeGraphTool(tool, config, graphClient, params, authManager)
       logger.info(`Setting custom Accept: ${config.acceptType}`);
     }
     const requestedSelect = parseSelectFields(queryParams["$select"]);
+    const enforcement = userFields === void 0 ? "none" : userFieldEnforcement(path2);
+    const isUserFieldBoundary = enforcement !== "none";
+    const boundaryFields = isUserFieldBoundary && userFields !== void 0 ? restrictUserFieldQuery(queryParams, userFields, enforcement) : [];
+    if (userFields !== void 0 && shouldStripUserFieldExpand(path2)) {
+      delete queryParams["$expand"];
+    }
+    if (isUserFieldBoundary) {
+      logger.info(
+        `Restricting ${tool.alias} to configured user fields (${enforcement}): ${boundaryFields}`
+      );
+    }
+    let batchRestricted = /* @__PURE__ */ new Map();
+    if (userFields !== void 0) {
+      const restrictedBatch = restrictBatchSubrequests(body, userFields);
+      body = restrictedBatch.body;
+      batchRestricted = restrictedBatch.restricted;
+    }
+    const projectionSelect = isUserFieldBoundary ? boundaryFields : requestedSelect;
     const keepFields = [
-      .../* @__PURE__ */ new Set([...requestedSelect, ...parseSelectFields(queryParams["$expand"])])
+      .../* @__PURE__ */ new Set([...projectionSelect, ...parseSelectFields(queryParams["$expand"])])
     ];
     if (Object.keys(queryParams).length > 0) {
       const queryString = Object.entries(queryParams).map(([key, value]) => `${key}=${encodeURIComponent(value).replace(/%2C/gi, ",")}`).join("&");
@@ -1430,8 +1535,9 @@ async function executeGraphTool(tool, config, graphClient, params, authManager)
       );
     }
     const mergePages = fetchAllPages && paginationEnabled;
-    const willProject = requestedSelect.length > 0 && params.excludeResponse !== true;
-    if (mergePages || willProject) {
+    const willProject = (requestedSelect.length > 0 || isUserFieldBoundary) && params.excludeResponse !== true;
+    const willProjectBatch = batchRestricted.size > 0 && params.excludeResponse !== true;
+    if (mergePages || willProject || willProjectBatch) {
       options.forceJsonOutput = true;
     }
     let response = await graphClient.graphRequest(path2, options);
@@ -1442,13 +1548,13 @@ async function executeGraphTool(tool, config, graphClient, params, authManager)
         logger.info("Skipping $select projection: body is a transport envelope, not a resource");
         return body2;
       }
-      if (!anyFieldPresent(body2, requestedSelect)) {
+      if (!isUserFieldBoundary && !anyFieldPresent(body2, projectionSelect)) {
         logger.warn(
-          `None of the requested $select fields (${requestedSelect.join(",")}) appear in the response; returning it untrimmed`
+          `None of the requested $select fields (${projectionSelect.join(",")}) appear in the response; returning it untrimmed`
         );
         return body2;
       }
-      return projectSelectedFields(body2, keepFields);
+      return projectSelectedFields(body2, keepFields, isUserFieldBoundary);
     };
     if (mergePages && response?.content?.[0]?.text) {
       let combinedResponse;
@@ -1535,6 +1641,15 @@ async function executeGraphTool(tool, config, graphClient, params, authManager)
       } catch {
       }
     }
+    if (willProjectBatch && !response?.isError && response?.content?.[0]?.text) {
+      try {
+        const parsed = JSON.parse(response.content[0].text);
+        response.content[0].text = graphClient.serialize(
+          projectBatchSubresponses(parsed, batchRestricted)
+        );
+      } catch {
+      }
+    }
     if (response?.content?.[0]?.text) {
       const responseText = response.content[0].text;
       logger.info(`Response size: ${responseText.length} characters`);
@@ -1599,7 +1714,19 @@ async function executeGraphTool(tool, config, graphClient, params, authManager)
     };
   }
 }
-function registerGraphTools(server, graphClient, readOnly = false, enabledToolsPattern, orgMode = false, authManager, multiAccount = false, accountNames = [], allowedScopesValue, httpMode = false) {
+function registerGraphTools(server, graphClient, options = {}) {
+  const {
+    readOnly = false,
+    enabledTools: enabledToolsPattern,
+    orgMode = false,
+    authManager,
+    multiAccount = false,
+    accountNames = [],
+    allowedScopes: allowedScopesValue,
+    httpMode = false,
+    userFields: userFieldsValue
+  } = options;
+  const userFields = parseUserFields(userFieldsValue);
   let enabledToolsRegex;
   if (enabledToolsPattern) {
     try {
@@ -1718,7 +1845,7 @@ function registerGraphTools(server, graphClient, readOnly = false, enabledToolsP
             // All tools call Microsoft Graph API
           }
         },
-        async (params) => executeGraphTool(tool, endpointConfig, graphClient, params, authManager)
+        async (params) => executeGraphTool(tool, endpointConfig, graphClient, params, authManager, userFields)
       );
       registeredCount++;
     } catch (error) {
@@ -1738,7 +1865,8 @@ function registerGraphTools(server, graphClient, readOnly = false, enabledToolsP
     graphClient,
     authManager,
     multiAccount,
-    accountNames
+    accountNames,
+    userFields
   };
   for (const utility of UTILITY_TOOLS) {
     if (readOnly && !utility.readOnlyHint) continue;
@@ -1859,7 +1987,19 @@ function scoreDiscoveryQuery(query, index) {
   ranked.sort((a, b) => b.score - a.score);
   return ranked;
 }
-function registerDiscoveryTools(server, graphClient, readOnly = false, orgMode = false, authManager, multiAccount = false, accountNames = [], enabledTools, allowedScopesValue, httpMode = false) {
+function registerDiscoveryTools(server, graphClient, options = {}) {
+  const {
+    readOnly = false,
+    enabledTools,
+    orgMode = false,
+    authManager,
+    multiAccount = false,
+    accountNames = [],
+    allowedScopes: allowedScopesValue,
+    httpMode = false,
+    userFields: userFieldsValue
+  } = options;
+  const userFields = parseUserFields(userFieldsValue);
   let enabledToolsRegex;
   if (enabledTools) {
     try {
@@ -1906,7 +2046,8 @@ function registerDiscoveryTools(server, graphClient, readOnly = false, orgMode =
     graphClient,
     authManager,
     multiAccount,
-    accountNames
+    accountNames,
+    userFields
   };
   const utilityByName = new Map(utilityTools.map((u) => [u.name, u]));
   const categoryNames = Object.keys(TOOL_CATEGORIES).join(", ");
@@ -2047,7 +2188,8 @@ function registerDiscoveryTools(server, graphClient, readOnly = false, orgMode =
           toolData.config,
           graphClient,
           parameters,
-          authManager
+          authManager,
+          userFields
         );
       }
       const utility = utilityByName.get(tool_name);

package/dist/lib/select-projection.js

@@ -23,8 +23,9 @@ function parseSelectFields(value) {
     )
   ];
 }
-function isAlwaysKept(key) {
-  return key.toLowerCase() === "id" || key.startsWith("@") || key.startsWith("_");
+function isAlwaysKept(key, strict = false) {
+  if (key.startsWith("@") || key.startsWith("_")) return true;
+  return !strict && key.toLowerCase() === "id";
 }
 const TRANSPORT_OK_MESSAGE = "OK!";
 function isTransportEnvelope(data) {
@@ -50,28 +51,28 @@ function anyFieldPresent(data, fields) {
   if (objects.length === 0) return true;
   return objects.some((item) => Object.keys(item).some((key) => wanted.has(key.toLowerCase())));
 }
-function projectObject(item, wanted) {
+function projectObject(item, wanted, strict) {
   if (!isPlainObject(item)) return item;
   const projected = {};
   for (const [key, value] of Object.entries(item)) {
-    if (isAlwaysKept(key) || wanted.has(key.toLowerCase())) {
+    if (isAlwaysKept(key, strict) || wanted.has(key.toLowerCase())) {
       projected[key] = value;
     }
   }
   return projected;
 }
-function projectSelectedFields(data, fields) {
+function projectSelectedFields(data, fields, strict = false) {
   if (fields.length === 0) return data;
   if (!data || typeof data !== "object") return data;
   const wanted = new Set(fields.map((field) => field.toLowerCase()));
   if (Array.isArray(data)) {
-    return data.map((item) => projectObject(item, wanted));
+    return data.map((item) => projectObject(item, wanted, strict));
   }
   const body = data;
   if (Array.isArray(body.value)) {
-    return { ...body, value: body.value.map((item) => projectObject(item, wanted)) };
+    return { ...body, value: body.value.map((item) => projectObject(item, wanted, strict)) };
   }
-  return projectObject(body, wanted);
+  return projectObject(body, wanted, strict);
 }
 export {
   TRANSPORT_OK_MESSAGE,

package/dist/lib/user-field-policy.js

@@ -0,0 +1,69 @@
+import { parseSelectFields } from "./select-projection.js";
+const USER_ENTITY_PATH = /^\/users(?:\/[^/]+)?\/?$/i;
+const DIRECTORY_NAVIGATION_PATH = /^(?:\/me|\/users\/[^/]+)\/(?:manager|directReports)\/?$|^\/groups\/[^/]+\/(?:members|owners)\/?$/i;
+const EXPAND_USER_PATH = /^\/me\/?$|^\/groups(?:\/[^/]+)?\/?$/i;
+function normalizePath(path) {
+  const withoutQuery = path.split("?")[0];
+  return withoutQuery.startsWith("/") ? withoutQuery : `/${withoutQuery}`;
+}
+function userFieldEnforcement(path) {
+  const normalized = normalizePath(path);
+  if (USER_ENTITY_PATH.test(normalized)) return "request-and-response";
+  if (DIRECTORY_NAVIGATION_PATH.test(normalized)) return "response-only";
+  return "none";
+}
+function targetsUserProfile(path) {
+  return userFieldEnforcement(path) !== "none";
+}
+function shouldStripUserFieldExpand(path) {
+  const normalized = normalizePath(path);
+  return userFieldEnforcement(normalized) !== "none" || EXPAND_USER_PATH.test(normalized);
+}
+function stripUserFieldExpandFromUrl(url) {
+  const [path, query = ""] = url.split("?");
+  if (!shouldStripUserFieldExpand(path) || query === "") return url;
+  const params = new URLSearchParams(query);
+  if (!params.has("$expand")) return url;
+  params.delete("$expand");
+  const rebuilt = params.toString();
+  if (rebuilt === "") return path;
+  return `${path}?${rebuilt.replace(/%24/gi, "$").replace(/%2C/gi, ",")}`;
+}
+function effectiveUserFields(requestedSelect, allowlist) {
+  const allowed = requestedSelect.filter(
+    (field) => allowlist.some((entry) => entry.toLowerCase() === field.toLowerCase())
+  );
+  return allowed.length > 0 ? allowed : allowlist;
+}
+function restrictUserFieldQuery(queryParams, allowlist, enforcement) {
+  const fields = effectiveUserFields(parseSelectFields(queryParams["$select"]), allowlist);
+  if (enforcement === "request-and-response") {
+    queryParams["$select"] = fields.join(",");
+  }
+  delete queryParams["$expand"];
+  return fields;
+}
+function restrictUserFieldUrl(url, allowlist, enforcement) {
+  const [path, query = ""] = url.split("?");
+  const params = new URLSearchParams(query);
+  const fields = effectiveUserFields(
+    parseSelectFields(params.get("$select") ?? void 0),
+    allowlist
+  );
+  if (enforcement === "request-and-response") {
+    params.set("$select", fields.join(","));
+  }
+  params.delete("$expand");
+  const rebuilt = params.toString();
+  if (rebuilt === "") return { url: path, fields };
+  return { url: `${path}?${rebuilt.replace(/%24/gi, "$").replace(/%2C/gi, ",")}`, fields };
+}
+export {
+  effectiveUserFields,
+  restrictUserFieldQuery,
+  restrictUserFieldUrl,
+  shouldStripUserFieldExpand,
+  stripUserFieldExpandFromUrl,
+  targetsUserProfile,
+  userFieldEnforcement
+};

package/dist/server.js

@@ -1,22 +1,27 @@
+import { mcpAuthRouter } from "@modelcontextprotocol/sdk/server/auth/router.js";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { hostHeaderValidation } from "@modelcontextprotocol/sdk/server/middleware/hostHeaderValidation.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
-import { mcpAuthRouter } from "@modelcontextprotocol/sdk/server/auth/router.js";
 import express from "express";
-import helmet from "helmet";
 import rateLimit from "express-rate-limit";
-import logger, { enableConsoleLogging } from "./logger.js";
+import helmet from "helmet";
+import crypto from "node:crypto";
+import { isIP, isIPv6 } from "node:net";
+import { createAttachmentHandler } from "./attachment-route.js";
 import { registerAuthTools } from "./auth-tools.js";
-import { registerGraphTools, registerDiscoveryTools } from "./graph-tools.js";
-import { buildMcpServerInstructions } from "./mcp-instructions.js";
-import { installToolSchemaRefNormalization } from "./normalize-tool-schema.js";
-import GraphClient from "./graph-client.js";
 import {
   buildScopesFromEndpoints,
   parseAllowedScopes,
   resolveAuthScopes
 } from "./auth.js";
-import { MicrosoftOAuthProvider } from "./oauth-provider.js";
+import { getCloudEndpoints } from "./cloud-config.js";
+import { dumpError } from "./crash-logging.js";
+import GraphClient from "./graph-client.js";
+import { registerDiscoveryTools, registerGraphTools } from "./graph-tools.js";
+import { configureAttachmentMinting } from "./lib/attachment-minting.js";
+import { AttachmentTicketStore } from "./lib/attachment-tickets.js";
+import { ATTACHMENT_ROUTE, loadAttachmentUrlConfig } from "./lib/attachment-url-config.js";
 import {
   exchangeCodeForToken,
   microsoftBearerTokenAuthMiddleware,
@@ -25,18 +30,13 @@ import {
   toOAuthErrorResponse
 } from "./lib/microsoft-auth.js";
 import { isAllowedRedirectUri, parseAllowlist } from "./lib/redirect-uri-validation.js";
-import { loadAttachmentUrlConfig, ATTACHMENT_ROUTE } from "./lib/attachment-url-config.js";
-import { AttachmentTicketStore } from "./lib/attachment-tickets.js";
-import { configureAttachmentMinting } from "./lib/attachment-minting.js";
-import { createAttachmentHandler } from "./attachment-route.js";
-import { getSecrets } from "./secrets.js";
-import { getCloudEndpoints } from "./cloud-config.js";
-import { requestContext } from "./request-context.js";
-import { dumpError } from "./crash-logging.js";
-import crypto from "node:crypto";
-import { isIP, isIPv6 } from "node:net";
+import logger, { enableConsoleLogging } from "./logger.js";
+import { buildMcpServerInstructions } from "./mcp-instructions.js";
+import { installToolSchemaRefNormalization } from "./normalize-tool-schema.js";
+import { MicrosoftOAuthProvider } from "./oauth-provider.js";
 import OboClient from "./obo-client.js";
-import { hostHeaderValidation } from "@modelcontextprotocol/sdk/server/middleware/hostHeaderValidation.js";
+import { requestContext } from "./request-context.js";
+import { getSecrets } from "./secrets.js";
 const LOOPBACK_HOSTNAMES = ["localhost", "127.0.0.1", "[::1]"];
 function isLoopbackHost(host) {
   if (!host) return false;
@@ -187,32 +187,21 @@ class MicrosoftGraphServer {
     if (shouldRegisterAuthTools) {
       registerAuthTools(server, this.authManager);
     }
+    const registrationOptions = {
+      readOnly: this.options.readOnly,
+      enabledTools: this.options.enabledTools,
+      orgMode: this.options.orgMode,
+      authManager: this.authManager,
+      multiAccount: this.multiAccount,
+      accountNames: this.accountNames,
+      allowedScopes: this.options.allowedScopes,
+      httpMode: this.hidesStdioOnlyTools(),
+      userFields: this.options.userFields
+    };
     if (this.options.discovery) {
-      registerDiscoveryTools(
-        server,
-        this.graphClient,
-        this.options.readOnly,
-        this.options.orgMode,
-        this.authManager,
-        this.multiAccount,
-        this.accountNames,
-        this.options.enabledTools,
-        this.options.allowedScopes,
-        this.hidesStdioOnlyTools()
-      );
+      registerDiscoveryTools(server, this.graphClient, registrationOptions);
     } else {
-      registerGraphTools(
-        server,
-        this.graphClient,
-        this.options.readOnly,
-        this.options.enabledTools,
-        this.options.orgMode,
-        this.authManager,
-        this.multiAccount,
-        this.accountNames,
-        this.options.allowedScopes,
-        this.hidesStdioOnlyTools()
-      );
+      registerGraphTools(server, this.graphClient, registrationOptions);
     }
     installToolSchemaRefNormalization(server);
     return server;
@@ -529,7 +518,8 @@ class MicrosoftGraphServer {
           this.options.enabledTools,
           this.options.readOnly
         );
-        const scopeSet = /* @__PURE__ */ new Set([...baseScopes, "User.Read", "offline_access"]);
+        const oboExtraScopes = this.options.obo ? parseAllowedScopes(this.options.extraScopes) ?? [] : [];
+        const scopeSet = /* @__PURE__ */ new Set([...baseScopes, ...oboExtraScopes, "User.Read", "offline_access"]);
         microsoftAuthUrl.searchParams.set("scope", Array.from(scopeSet).join(" "));
         res.redirect(microsoftAuthUrl.toString());
       });

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@softeria/ms-365-mcp-server",
   "mcpName": "io.github.Softeria/ms-365-mcp-server",
-  "version": "0.157.1",
+  "version": "0.158.0",
   "description": " A Model Context Protocol (MCP) server for interacting with Microsoft 365 and Office services through the Graph API",
   "type": "module",
   "main": "dist/index.js",